TCF Agent Porting Guide

# HG changeset patch # User duane.cawthron@nokia.com # Date 1250542920 18000 # Node ID 11a6943ebeb2bab5af0823002b9fd634db5f5cde # Parent b6b7ad8a25a38dfaf9a4594cd447a14e7670287e add dsdp/tm/tcf_0_3_x diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/.classpath --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/.classpath Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,6 @@ + + + + + + diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/.project --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/.project Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,28 @@ + + + org.eclipse.tm.tcf.core + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.pde.ManifestBuilder + + + + + org.eclipse.pde.SchemaBuilder + + + + + + org.eclipse.pde.PluginNature + org.eclipse.jdt.core.javanature + + diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/.settings/org.eclipse.jdt.core.prefs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/.settings/org.eclipse.jdt.core.prefs Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,279 @@ +#Mon Jun 22 11:36:07 PDT 2009 +eclipse.preferences.version=1 +org.eclipse.jdt.core.builder.cleanOutputFolder=clean +org.eclipse.jdt.core.builder.duplicateResourceTask=warning +org.eclipse.jdt.core.builder.invalidClasspath=abort +org.eclipse.jdt.core.builder.recreateModifiedClassFileInOutputFolder=ignore +org.eclipse.jdt.core.builder.resourceCopyExclusionFilter=*.launch,.svn/ +org.eclipse.jdt.core.circularClasspath=error +org.eclipse.jdt.core.classpath.exclusionPatterns=enabled +org.eclipse.jdt.core.classpath.multipleOutputLocations=enabled +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.5 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.maxProblemPerUnit=100 +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.5 +org.eclipse.jdt.core.formatter.align_type_members_on_columns=false +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_assignment=0 +org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_compact_if=16 +org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80 +org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16 +org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16 +org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16 +org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16 +org.eclipse.jdt.core.formatter.blank_lines_after_imports=1 +org.eclipse.jdt.core.formatter.blank_lines_after_package=1 +org.eclipse.jdt.core.formatter.blank_lines_before_field=1 +org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0 +org.eclipse.jdt.core.formatter.blank_lines_before_imports=1 +org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1 +org.eclipse.jdt.core.formatter.blank_lines_before_method=1 +org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1 +org.eclipse.jdt.core.formatter.blank_lines_before_package=0 +org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1 +org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1 +org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line +org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false +org.eclipse.jdt.core.formatter.comment.format_block_comments=true +org.eclipse.jdt.core.formatter.comment.format_header=false +org.eclipse.jdt.core.formatter.comment.format_html=true +org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true +org.eclipse.jdt.core.formatter.comment.format_line_comments=true +org.eclipse.jdt.core.formatter.comment.format_source_code=true +org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true +org.eclipse.jdt.core.formatter.comment.indent_root_tags=true +org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert +org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert +org.eclipse.jdt.core.formatter.comment.line_length=80 +org.eclipse.jdt.core.formatter.compact_else_if=true +org.eclipse.jdt.core.formatter.continuation_indentation=2 +org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2 +org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true +org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true +org.eclipse.jdt.core.formatter.indent_empty_lines=false +org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true +org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true +org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true +org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=false +org.eclipse.jdt.core.formatter.indentation.size=8 +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_member=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=insert +org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=insert +org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=insert +org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=insert +org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert +org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert +org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert +org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert +org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert +org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false +org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false +org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=true +org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false +org.eclipse.jdt.core.formatter.lineSplit=80 +org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false +org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0 +org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1 +org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true +org.eclipse.jdt.core.formatter.tabulation.char=space +org.eclipse.jdt.core.formatter.tabulation.size=4 +org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false +org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true +org.eclipse.jdt.core.incompatibleJDKLevel=ignore +org.eclipse.jdt.core.incompleteClasspath=error diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/.settings/org.eclipse.jdt.ui.prefs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/.settings/org.eclipse.jdt.ui.prefs Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,4 @@ +#Thu May 21 14:51:03 PDT 2009 +eclipse.preferences.version=1 +formatter_profile=_Java STD +formatter_settings_version=11 diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/META-INF/MANIFEST.MF --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/META-INF/MANIFEST.MF Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,11 @@ +Manifest-Version: 1.0 +Bundle-ManifestVersion: 2 +Bundle-Name: TCF Core Fragment +Bundle-SymbolicName: org.eclipse.tm.tcf.core;singleton:=true +Bundle-Version: 0.2.0.qualifier +Fragment-Host: org.eclipse.tm.tcf;bundle-version="0.2.0" +Bundle-RequiredExecutionEnvironment: J2SE-1.5 +Export-Package: org.eclipse.tm.tcf.core;version="0.2.0", + org.eclipse.tm.tcf.protocol;version="0.2.0", + org.eclipse.tm.tcf.services;version="0.2.0", + org.eclipse.tm.tcf.util;version="0.2.0" diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/build.properties --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/build.properties Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,4 @@ +source.. = src/ +output.. = bin/ +bin.includes = META-INF/,\ + . diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/core/ChannelLoop.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/core/ChannelLoop.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,91 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.core; + +import java.io.IOException; +import java.io.InterruptedIOException; + +import org.eclipse.tm.tcf.core.StreamChannel; +import org.eclipse.tm.tcf.protocol.IPeer; + + +public class ChannelLoop extends StreamChannel { + + private final byte[] buf = new byte[0x1000]; + private int buf_inp; + private int buf_out; + private boolean waiting; + private boolean closed; + + ChannelLoop(IPeer peer) { + super(peer); + start(); + } + + @Override + protected synchronized int get() throws IOException { + try { + while (buf_inp == buf_out) { + if (closed) return -1; + waiting = true; + wait(); + } + int b = buf[buf_out] & 0xff; + buf_out = (buf_out + 1) % buf.length; + if (waiting) { + waiting = false; + notifyAll(); + } + return b; + } + catch (InterruptedException e) { + throw new InterruptedIOException(); + } + } + + @Override + protected synchronized void put(int b) throws IOException { + assert b >=0 && b <= 0xff; + try { + for (;;) { + int nxt_inp = (buf_inp + 1) % buf.length; + if (nxt_inp != buf_out) { + buf[buf_inp] = (byte)b; + buf_inp = nxt_inp; + break; + } + if (closed) return; + waiting = true; + wait(); + } + if (waiting) { + waiting = false; + notifyAll(); + } + } + catch (InterruptedException e) { + throw new InterruptedIOException(); + } + } + + @Override + protected void flush() throws IOException { + } + + @Override + protected synchronized void stop() throws IOException { + closed = true; + if (waiting) { + waiting = false; + notifyAll(); + } + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/core/LocalPeer.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/core/LocalPeer.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,32 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.core; + +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.tm.tcf.core.AbstractPeer; + +public class LocalPeer extends AbstractPeer { + + private static Map createAttributes() { + Map attrs = new HashMap(); + attrs.put(ATTR_ID, "TCFLocal"); + attrs.put(ATTR_NAME, "Local Peer"); + attrs.put(ATTR_OS_NAME, System.getProperty("os.name")); + attrs.put(ATTR_TRANSPORT_NAME, "Loop"); + return attrs; + } + + public LocalPeer() { + super(createAttributes()); + } +} \ No newline at end of file diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/core/RemotePeer.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/core/RemotePeer.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,35 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.core; + +import java.util.Map; + +import org.eclipse.tm.tcf.core.AbstractPeer; + +public class RemotePeer extends AbstractPeer { + + private long last_update_time; + + public RemotePeer(Map attrs) { + super(attrs); + last_update_time = System.currentTimeMillis(); + } + + @Override + public void updateAttributes(Map attrs) { + super.updateAttributes(attrs); + last_update_time = System.currentTimeMillis(); + } + + public long getLastUpdateTime() { + return last_update_time; + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/core/ServiceManager.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/core/ServiceManager.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,90 @@ +/******************************************************************************* + * Copyright (c) 2008 Anyware Technologies and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Anyware Technologies - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.core; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Map; + +import org.eclipse.tm.internal.tcf.services.local.DiagnosticsService; +import org.eclipse.tm.internal.tcf.services.remote.GenericProxy; +import org.eclipse.tm.internal.tcf.services.remote.LocatorProxy; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IService; +import org.eclipse.tm.tcf.protocol.IServiceProvider; + +public class ServiceManager { + + private static final Collection providers = new ArrayList(); + + static { + addServiceProvider(new IServiceProvider() { + + private final String package_name = LocatorProxy.class.getPackage().getName(); + + public IService[] getLocalService(IChannel channel) { + return new IService[]{ new DiagnosticsService(channel) }; + } + + public IService getServiceProxy(IChannel channel, String service_name) { + IService service = null; + try { + Class cls = Class.forName(package_name + "." + service_name + "Proxy"); + service = (IService)cls.getConstructor(IChannel.class).newInstance(channel); + assert service_name.equals(service.getName()); + } + catch (Exception x) { + } + return service; + } + }); + + } + + public static void addServiceProvider(IServiceProvider provider) { + providers.add(provider); + } + + public static void removeServiceProvider(IServiceProvider provider) { + providers.remove(provider); + } + + public static void onChannelCreated(IChannel channel, Map services) { + IService zero_copy = new IService() { + public String getName() { + return "ZeroCopy"; + } + }; + services.put(zero_copy.getName(), zero_copy); + for (IServiceProvider provider : providers) { + IService[] arr = provider.getLocalService(channel); + if (arr == null) continue; + for (IService service : arr) { + if (services.containsKey(service.getName())) continue; + services.put(service.getName(), service); + } + } + } + + public static void onChannelOpened(IChannel channel, Collection service_names, Map services) { + for (String name : service_names) { + for (IServiceProvider provider : providers) { + IService service = provider.getServiceProxy(channel, name); + if (service == null) continue; + services.put(name, service); + break; + } + if (!services.containsKey(name)) { + services.put(name, new GenericProxy(channel, name)); + } + } + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/core/Token.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/core/Token.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,75 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.core; + +import java.io.UnsupportedEncodingException; + +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IToken; + + +public class Token implements IToken { + + private static int cnt = 0; + + private final String id; + private final byte[] bytes; + private final IChannel.ICommandListener listener; + + public Token() { + id = null; + bytes = null; + listener = null; + } + + public Token(IChannel.ICommandListener listener) { + this.listener = listener; + id = Integer.toString(cnt++); + try { + bytes = id.getBytes("ASCII"); + } + catch (UnsupportedEncodingException e) { + throw new Error(e); + } + } + + public Token(byte[] bytes) { + this.bytes = bytes; + listener = null; + try { + id = new String(bytes, "ASCII"); + } + catch (UnsupportedEncodingException e) { + throw new Error(e); + } + } + + public boolean cancel() { + return false; + } + + public String getID() { + return id; + } + + public byte[] getBytes() { + return bytes; + } + + public IChannel.ICommandListener getListener() { + return listener; + } + + @Override + public String toString() { + return id; + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/core/TransportManager.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/core/TransportManager.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,198 @@ +/******************************************************************************* + * Copyright (c) 2007-2009 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.core; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.Map; +import java.util.Set; + +import org.eclipse.tm.tcf.core.AbstractChannel; +import org.eclipse.tm.tcf.core.AbstractPeer; +import org.eclipse.tm.tcf.core.ChannelTCP; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IPeer; +import org.eclipse.tm.tcf.protocol.IService; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.ITransportProvider; +import org.eclipse.tm.tcf.protocol.Protocol; +import org.eclipse.tm.tcf.services.ILocator; + + +public class TransportManager { + + private static final Collection channels = + new LinkedList(); + private static final Collection listeners = + new LinkedList(); + private static final HashMap transports = + new HashMap(); + + static { + addTransportProvider(new ITransportProvider() { + + public String getName() { + return "TCP"; + } + + public IChannel openChannel(IPeer peer) { + assert getName().equals(peer.getTransportName()); + Map attrs = peer.getAttributes(); + String host = attrs.get(IPeer.ATTR_IP_HOST); + String port = attrs.get(IPeer.ATTR_IP_PORT); + if (host == null) throw new Error("No host name"); + if (port == null) throw new Error("No port number"); + return new ChannelTCP(peer, host, Integer.parseInt(port), false); + } + }); + + addTransportProvider(new ITransportProvider() { + + public String getName() { + return "SSL"; + } + + public IChannel openChannel(IPeer peer) { + assert getName().equals(peer.getTransportName()); + Map attrs = peer.getAttributes(); + String host = attrs.get(IPeer.ATTR_IP_HOST); + String port = attrs.get(IPeer.ATTR_IP_PORT); + if (host == null) throw new Error("No host name"); + if (port == null) throw new Error("No port number"); + return new ChannelTCP(peer, host, Integer.parseInt(port), true); + } + }); + + addTransportProvider(new ITransportProvider() { + + public String getName() { + return "Loop"; + } + + public IChannel openChannel(IPeer peer) { + assert getName().equals(peer.getTransportName()); + return new ChannelLoop(peer); + } + }); + } + + public static void addTransportProvider(ITransportProvider transport) { + String name = transport.getName(); + assert name != null; + if (transports.get(name) != null) throw new Error("Already registered: " + name); + transports.put(name, transport); + } + + public static void removeTransportProvider(ITransportProvider transport) { + String name = transport.getName(); + assert name != null; + if (transports.get(name) == transport) transports.remove(name); + } + + public static IChannel openChannel(IPeer peer) { + String name = peer.getTransportName(); + if (name == null) throw new Error("No transport name"); + ITransportProvider transport = transports.get(name); + if (transport == null) throw new Error("Unknown transport name: " + name); + return transport.openChannel(peer); + } + + public static void channelOpened(final AbstractChannel channel) { + assert !channels.contains(channel); + channels.add(channel); + Protocol.ChannelOpenListener[] array = listeners.toArray(new Protocol.ChannelOpenListener[listeners.size()]); + for (Protocol.ChannelOpenListener l : array) { + try { + l.onChannelOpen(channel); + } + catch (Throwable x) { + Protocol.log("Exception in channel listener", x); + } + } + } + + public static void channelClosed(final AbstractChannel channel, final Throwable x) { + assert channels.contains(channel); + channels.remove(channel); + } + + public static IChannel[] getOpenChannels() { + return channels.toArray(new IChannel[channels.size()]); + } + + public static void addChanelOpenListener(Protocol.ChannelOpenListener listener) { + assert listener != null; + listeners.add(listener); + } + + public static void removeChanelOpenListener(Protocol.ChannelOpenListener listener) { + listeners.remove(listener); + } + + public static void peerDisposed(AbstractPeer peer) { + Exception error = null; + Collection bf = new ArrayList(channels); + for (Iterator i = bf.iterator(); i.hasNext();) { + AbstractChannel c = i.next(); + if (c.getRemotePeer() != peer) continue; + if (error == null) error = new Exception("Peer is disposed"); + c.terminate(error); + } + } + + /** + * Transmit TCF event message. + * The message is sent to all open communication channels � broadcasted. + * + * This is internal API, TCF clients should use {@code org.eclipse.tm.tcf.protocol.Protocol}. + */ + public static void sendEvent(String service_name, String event_name, byte[] data) { + for (Iterator i = channels.iterator(); i.hasNext();) { + AbstractChannel channel = i.next(); + IService s = channel.getLocalService(service_name); + if (s != null) channel.sendEvent(s, event_name, data); + } + } + + /** + * Call back after TCF messages sent by this host up to this moment are delivered + * to their intended targets. This method is intended for synchronization of messages + * across multiple channels. + * + * Note: Cross channel synchronization can reduce performance and throughput. + * Most clients don't need cross channel synchronization and should not call this method. + * + * @param done will be executed by dispatch thread after communication + * messages are delivered to corresponding targets. + * + * This is internal API, TCF clients should use {@code org.eclipse.tm.tcf.protocol.Protocol}. + */ + public static void sync(final Runnable done) { + final Set set = new HashSet(); + ILocator.DoneSync done_sync = new ILocator.DoneSync() { + public void doneSync(IToken token) { + assert set.contains(token); + set.remove(token); + if (set.isEmpty()) done.run(); + } + }; + for (Iterator i = channels.iterator(); i.hasNext();) { + AbstractChannel channel = i.next(); + ILocator s = channel.getRemoteService(ILocator.class); + if (s != null) set.add(s.sync(done_sync)); + } + if (set.isEmpty()) Protocol.invokeLater(done); + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/local/ChannelProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/local/ChannelProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,154 @@ +/******************************************************************************* + * Copyright (c) 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.local; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.tm.internal.tcf.core.ChannelLoop; +import org.eclipse.tm.tcf.core.AbstractChannel; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IService; +import org.eclipse.tm.tcf.protocol.IToken; + +/** + * ChannelProxy implements forwarding of TCF messages between two channels. + * The class is used to implement Locator service "redirect" command. + */ +class ChannelProxy { + + private final AbstractChannel ch_x; + private final AbstractChannel ch_y; + + private boolean closed_x; + private boolean closed_y; + + private final Map tokens_x = new HashMap(); + private final Map tokens_y = new HashMap(); + + private final AbstractChannel.Proxy proxy_x = new AbstractChannel.Proxy() { + + public void onChannelClosed(Throwable error) { + closed_x = true; + if (closed_y) return; + if (error == null) ch_y.close(); + else ch_y.terminate(error); + } + + public void onCommand(IToken token, String service, String name, byte[] data) { + if (closed_y) return; + assert ch_y.getState() == IChannel.STATE_OPEN; + IService s = ch_y.getRemoteService(service); + if (s == null) ch_x.terminate(new IOException("Invalid service name")); + else tokens_x.put(ch_y.sendCommand(s, name, data, cmd_listener_x), token); + } + + public void onEvent(String service, String name, byte[] data) { + IService s = ch_x.getRemoteService(service); + if (s == null) ch_x.terminate(new IOException("Invalid service name")); + else if (!closed_y) ch_y.sendEvent(s, name, data); + } + }; + + private final AbstractChannel.Proxy proxy_y = new AbstractChannel.Proxy() { + + public void onChannelClosed(Throwable error) { + closed_y = true; + if (closed_x) return; + if (error == null) ch_x.close(); + else ch_x.terminate(error); + } + + public void onCommand(IToken token, String service, String name, byte[] data) { + if (closed_x) return; + assert ch_x.getState() == IChannel.STATE_OPEN; + IService s = ch_x.getRemoteService(service); + if (s == null) ch_y.terminate(new IOException("Invalid service name")); + else tokens_y.put(ch_x.sendCommand(s, name, data, cmd_listener_y), token); + } + + public void onEvent(String service, String name, byte[] data) { + IService s = ch_y.getRemoteService(service); + if (s == null) ch_y.terminate(new IOException("Invalid service name")); + else if (!closed_x) ch_x.sendEvent(s, name, data); + } + }; + + private final IChannel.ICommandListener cmd_listener_x = new IChannel.ICommandListener() { + + public void progress(IToken token, byte[] data) { + ch_x.sendProgress(tokens_x.get(token), data); + } + + public void result(IToken token, byte[] data) { + ch_x.sendResult(tokens_x.get(token), data); + tokens_x.remove(token); + } + + public void terminated(IToken token, Exception error) { + tokens_x.remove(token); + } + }; + + private final IChannel.ICommandListener cmd_listener_y = new IChannel.ICommandListener() { + + public void progress(IToken token, byte[] data) { + ch_y.sendProgress(tokens_y.get(token), data); + } + + public void result(IToken token, byte[] data) { + ch_y.sendResult(tokens_y.get(token), data); + tokens_y.remove(token); + } + + public void terminated(IToken token, Exception error) { + tokens_y.remove(token); + } + }; + + ChannelProxy(IChannel x, IChannel y) { + assert !(x instanceof ChannelLoop); + assert !(y instanceof ChannelLoop); + ch_x = (AbstractChannel)x; + ch_y = (AbstractChannel)y; + assert ch_x.getState() == IChannel.STATE_OPEN; + assert ch_y.getState() == IChannel.STATE_OPENNING; + try { + ch_y.setProxy(proxy_y, ch_x.getRemoteServices()); + ch_y.addChannelListener(new IChannel.IChannelListener() { + + public void congestionLevel(int level) { + } + + public void onChannelClosed(Throwable error) { + ch_y.removeChannelListener(this); + if (error == null) error = new Exception("Channel closed"); + } + + public void onChannelOpened() { + ch_y.removeChannelListener(this); + try { + ch_x.setProxy(proxy_x, ch_y.getRemoteServices()); + } + catch (IOException e) { + ch_x.terminate(e); + ch_y.terminate(e); + } + } + }); + } + catch (IOException e) { + ch_x.terminate(e); + ch_y.terminate(e); + } + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/local/DiagnosticsService.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/local/DiagnosticsService.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,157 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.local; + +import java.math.BigDecimal; + +import org.eclipse.tm.internal.tcf.core.Token; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.protocol.Protocol; +import org.eclipse.tm.tcf.services.IDiagnostics; + + +public class DiagnosticsService implements IDiagnostics { + + private final IChannel channel; + + private class CommandServer implements IChannel.ICommandServer { + + public void command(IToken token, String name, byte[] data) { + try { + command(token, name, JSON.parseSequence(data)); + } + catch (Throwable x) { + channel.terminate(x); + } + } + + private void command(IToken token, String name, Object[] args) throws Exception { + if (name.equals("echo")) { + if (args.length != 1) throw new Exception("Invalid number of arguments"); + String s = (String)args[0]; + channel.sendResult(token, JSON.toJSONSequence(new Object[]{ s })); + } + else if (name.equals("echoFP")) { + if (args.length != 1) throw new Exception("Invalid number of arguments"); + Number n = (Number)args[0]; + channel.sendResult(token, JSON.toJSONSequence(new Object[]{ n })); + } + else if (name.equals("getTestList")) { + if (args.length != 0) throw new Exception("Invalid number of arguments"); + channel.sendResult(token, JSON.toJSONSequence(new Object[]{ null, new String[0] })); + } + else { + channel.rejectCommand(token); + } + } + } + + public DiagnosticsService(IChannel channel) { + this.channel = channel; + channel.addCommandServer(this, new CommandServer()); + } + + public String getName() { + return NAME; + } + + public IToken echo(final String s, final DoneEcho done) { + final IToken token = new Token(); + Protocol.invokeLater(new Runnable() { + public void run() { + done.doneEcho(token, null, s); + } + }); + return token; + } + + public IToken echoFP(final BigDecimal n, final DoneEchoFP done) { + final IToken token = new Token(); + Protocol.invokeLater(new Runnable() { + public void run() { + done.doneEchoFP(token, null, n); + } + }); + return token; + } + + public IToken getTestList(final DoneGetTestList done) { + final IToken token = new Token(); + Protocol.invokeLater(new Runnable() { + public void run() { + done.doneGetTestList(token, null, new String[0]); + } + }); + return token; + } + + public IToken runTest(final String s, final DoneRunTest done) { + final IToken token = new Token(); + Protocol.invokeLater(new Runnable() { + public void run() { + done.doneRunTest(token, new Exception("Test suite not found: " + s), null); + } + }); + return token; + } + + public IToken cancelTest(String context_id, final DoneCancelTest done) { + final IToken token = new Token(); + Protocol.invokeLater(new Runnable() { + public void run() { + done.doneCancelTest(token, null); + } + }); + return token; + } + + public IToken getSymbol(String context_id, String symbol_name, final DoneGetSymbol done) { + final IToken token = new Token(); + Protocol.invokeLater(new Runnable() { + public void run() { + done.doneGetSymbol(token, new Exception("Invalid context"), null); + } + }); + return token; + } + + public IToken createTestStreams(int inp_buf_size, int out_buf_size, final DoneCreateTestStreams done) { + final IToken token = new Token(); + Protocol.invokeLater(new Runnable() { + public void run() { + done.doneCreateTestStreams(token, new Exception("Not implemented"), null, null); + } + }); + return token; + } + + public IToken disposeTestStream(String id, final DoneDisposeTestStream done) { + final IToken token = new Token(); + Protocol.invokeLater(new Runnable() { + public void run() { + done.doneDisposeTestStream(token, new Exception("Invalid context")); + } + }); + return token; + } + + public IToken not_implemented_command(final DoneNotImplementedCommand done) { + final IToken token = new Token(); + Protocol.invokeLater(new Runnable() { + public void run() { + done.doneNotImplementedCommand(token, new Exception("Not implemented")); + } + }); + return token; + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/local/LocatorService.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/local/LocatorService.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,785 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.local; + +import java.lang.reflect.Method; +import java.net.BindException; +import java.net.DatagramPacket; +import java.net.DatagramSocket; +import java.net.InetAddress; +import java.net.NetworkInterface; +import java.net.SocketException; +import java.net.UnknownHostException; +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import org.eclipse.tm.internal.tcf.core.LocalPeer; +import org.eclipse.tm.internal.tcf.core.RemotePeer; +import org.eclipse.tm.internal.tcf.core.ServiceManager; +import org.eclipse.tm.internal.tcf.core.TransportManager; +import org.eclipse.tm.tcf.core.AbstractChannel; +import org.eclipse.tm.tcf.core.AbstractPeer; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IErrorReport; +import org.eclipse.tm.tcf.protocol.IPeer; +import org.eclipse.tm.tcf.protocol.IService; +import org.eclipse.tm.tcf.protocol.IServiceProvider; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.protocol.Protocol; +import org.eclipse.tm.tcf.services.ILocator; + + +/** + * Locator service uses transport layer to search + * for peers and to collect and maintain up-to-date + * data about peer�s attributes. + */ +// TODO: research usage of DNS-SD (DNS Service Discovery) to discover TCF peers +public class LocatorService implements ILocator { + + private static final int DISCOVEY_PORT = 1534; + private static final int MAX_PACKET_SIZE = 9000 - 40 - 8; + private static final int PREF_PACKET_SIZE = 1500 - 40 - 8; + + private static LocatorService locator; + private static final Map peers = new HashMap(); + private static final ArrayList listeners = new ArrayList(); + + private final HashSet subnets = new HashSet(); + private final ArrayList slaves = new ArrayList(); + private final byte[] inp_buf = new byte[MAX_PACKET_SIZE]; + private final byte[] out_buf = new byte[MAX_PACKET_SIZE]; + + private InetAddress loopback_addr; + + private static class SubNet { + final int prefix_length; + final InetAddress address; + final InetAddress broadcast; + + long last_slaves_req_time; + boolean send_all_ok; + + SubNet(int prefix_length, InetAddress address, InetAddress broadcast) { + this.prefix_length = prefix_length; + this.address = address; + this.broadcast = broadcast; + } + + boolean contains(InetAddress addr) { + if (addr == null) return false; + byte[] a1 = addr.getAddress(); + byte[] a2 = broadcast.getAddress(); + int i = 0; + while (i + 8 <= prefix_length) { + int n = i / 8; + if (a1[n] != a2[n]) return false; + i += 8; + } + while (i < prefix_length) { + int n = i / 8; + int m = 1 << (7 - i % 8); + if ((a1[n] & m) != (a2[n] & m)) return false; + i++; + } + return true; + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof SubNet)) return false; + SubNet x = (SubNet)o; + return + prefix_length == x.prefix_length && + broadcast.equals(x.broadcast) && + address.equals(x.address); + } + + @Override + public int hashCode() { + return broadcast.hashCode(); + } + + @Override + public String toString() { + return broadcast.getHostAddress() + "/" + prefix_length; + } + } + + private static class Slave { + final InetAddress address; + final int port; + + /* Time of last packet receiver from this slave */ + long last_packet_time; + + /* Time of last REQ_SLAVES packet received from this slave */ + long last_req_slaves_time; + + Slave(InetAddress address, int port) { + this.address = address; + this.port = port; + } + + @Override + public String toString() { + return address.getHostAddress() + ":" + port; + } + } + + private static LocalPeer local_peer; + + private DatagramSocket socket; + private long last_master_packet_time; + + private Thread timer_thread = new Thread() { + public void run() { + while (true) { + try { + sleep(DATA_RETENTION_PERIOD / 4); + Protocol.invokeAndWait(new Runnable() { + public void run() { + refresh_timer(); + } + }); + } + catch (IllegalStateException x) { + // TCF event dispatch is shut down + return; + } + catch (Throwable x) { + Protocol.log("Unhandled exception in TCF discovery listening thread", x); + } + } + } + }; + + private Thread input_thread = new Thread() { + public void run() { + for (;;) { + DatagramSocket socket = LocatorService.this.socket; + try { + final DatagramPacket p = new DatagramPacket(inp_buf, inp_buf.length); + socket.receive(p); + Protocol.invokeAndWait(new Runnable() { + public void run() { + handleDatagramPacket(p); + } + }); + } + catch (IllegalStateException x) { + // TCF event dispatch is shutdown + return; + } + catch (Exception x) { + if (socket != LocatorService.this.socket) continue; + Protocol.log("Cannot read from datagram socket", x); + } + } + } + }; + + static { + ServiceManager.addServiceProvider(new IServiceProvider() { + + public IService[] getLocalService(final IChannel channel) { + channel.addCommandServer(locator, new IChannel.ICommandServer() { + public void command(IToken token, String name, byte[] data) { + locator.command((AbstractChannel)channel, token, name, data); + } + }); + return new IService[]{ locator }; + } + + public IService getServiceProxy(IChannel channel, String service_name) { + return null; + } + }); + } + + public LocatorService() { + locator = this; + try { + loopback_addr = InetAddress.getByName(null); + out_buf[0] = 'T'; + out_buf[1] = 'C'; + out_buf[2] = 'F'; + out_buf[3] = CONF_VERSION; + out_buf[4] = 0; + out_buf[5] = 0; + out_buf[6] = 0; + out_buf[7] = 0; + try { + socket = new DatagramSocket(DISCOVEY_PORT); + } + catch (BindException x) { + socket = new DatagramSocket(); + } + socket.setBroadcast(true); + input_thread.setName("TCF Locator Receiver"); + timer_thread.setName("TCF Locator Timer"); + input_thread.setDaemon(true); + timer_thread.setDaemon(true); + input_thread.start(); + timer_thread.start(); + listeners.add(new LocatorListener() { + + public void peerAdded(IPeer peer) { + sendPeerInfo(peer, null, 0); + } + + public void peerChanged(IPeer peer) { + sendPeerInfo(peer, null, 0); + } + + public void peerHeartBeat(String id) { + } + + public void peerRemoved(String id) { + } + }); + refreshSubNetList(); + sendPeersRequest(null, 0); + sendAll(null, 0, null, System.currentTimeMillis()); + } + catch (Exception x) { + Protocol.log("Cannot open UDP socket for TCF discovery protocol", x); + } + } + + public static LocalPeer getLocalPeer() { + return local_peer; + } + + public static LocatorListener[] getListeners() { + return listeners.toArray(new LocatorListener[listeners.size()]); + } + + public static void addPeer(AbstractPeer peer) { + assert peers.get(peer.getID()) == null; + if (peer instanceof LocalPeer) local_peer = (LocalPeer)peer; + peers.put(peer.getID(), peer); + peer.sendPeerAddedEvent(); + } + + public static void removePeer(AbstractPeer peer) { + String id = peer.getID(); + assert peers.get(id) == peer; + peers.remove(id); + peer.sendPeerRemovedEvent(); + } + + private Map makeErrorReport(int code, String msg) { + Map err = new HashMap(); + err.put(IErrorReport.ERROR_TIME, new Long(System.currentTimeMillis())); + err.put(IErrorReport.ERROR_CODE, new Integer(code)); + err.put(IErrorReport.ERROR_FORMAT, msg); + return err; + } + + private void command(final AbstractChannel channel, final IToken token, String name, byte[] data) { + try { + if (name.equals("redirect")) { + String peer_id = (String)JSON.parseSequence(data)[0]; + IPeer peer = peers.get(peer_id); + if (peer == null) { + channel.sendResult(token, JSON.toJSONSequence(new Object[]{ + makeErrorReport(IErrorReport.TCF_ERROR_UNKNOWN_PEER, "Unknown peer ID") })); + return; + } + channel.sendResult(token, JSON.toJSONSequence(new Object[]{ null })); + if (peer instanceof LocalPeer) { + channel.sendEvent(Protocol.getLocator(), "Hello", JSON.toJSONSequence( + new Object[]{ channel.getLocalServices() })); + return; + } + new ChannelProxy(channel, peer.openChannel()); + } + else if (name.equals("sync")) { + channel.sendResult(token, null); + } + else if (name.equals("getPeers")) { + int i = 0; + Object[] arr = new Object[peers.size()]; + for (IPeer p : peers.values()) arr[i++] = p.getAttributes(); + channel.sendResult(token, JSON.toJSONSequence(new Object[]{ null, arr })); + } + else { + channel.rejectCommand(token); + } + } + catch (Throwable x) { + channel.terminate(x); + } + } + + private void refresh_timer() { + long time = System.currentTimeMillis(); + /* Cleanup slave table */ + if (slaves.size() > 0) { + int i = 0; + while (i < slaves.size()) { + Slave s = slaves.get(i); + if (s.last_packet_time + DATA_RETENTION_PERIOD < time) { + slaves.remove(i); + } + else { + i++; + } + } + } + /* Cleanup peers table */ + ArrayList stale_peers = null; + for (IPeer p : peers.values()) { + if (p instanceof RemotePeer) { + RemotePeer r = (RemotePeer)p; + if (r.getLastUpdateTime() + DATA_RETENTION_PERIOD < time) { + if (stale_peers == null) stale_peers = new ArrayList(); + stale_peers.add(r); + } + } + } + if (stale_peers != null) { + IChannel[] open_channels = TransportManager.getOpenChannels(); + HashSet connected_peers = new HashSet(); + for (IChannel c : open_channels) connected_peers.add(c.getRemotePeer()); + for (RemotePeer p : stale_peers) { + if (!connected_peers.contains(p)) p.dispose(); + } + } + /* Try to become a master */ + if (socket.getLocalPort() != DISCOVEY_PORT && last_master_packet_time + DATA_RETENTION_PERIOD / 2 <= time) { + DatagramSocket s0 = socket; + DatagramSocket s1 = null; + try { + s1 = new DatagramSocket(DISCOVEY_PORT); + s1.setBroadcast(true); + socket = s1; + s0.close(); + } + catch (Throwable x) { + } + } + refreshSubNetList(); + sendAll(null, 0, null, time); + } + + private Slave addSlave(InetAddress addr, int port, long timestamp) { + for (Slave s : slaves) { + if (s.port == port && s.address.equals(addr)) { + if (s.last_packet_time < timestamp) s.last_packet_time = timestamp; + return s; + } + } + long time = System.currentTimeMillis(); + Slave s = new Slave(addr, port); + s.last_packet_time = timestamp; + slaves.add(s); + sendPeersRequest(addr, port); + sendAll(addr, port, s, time); + sendSlaveInfo(s, time); + return s; + } + + private void refreshSubNetList() { + HashSet set = new HashSet(); + try { + for (Enumeration e = NetworkInterface.getNetworkInterfaces(); e.hasMoreElements();) { + NetworkInterface f = e.nextElement(); + /* TODO: Class InterfaceAddress does not exists in Java versions before 1.6. + * Fix the code below when support for old Java versions is not needed any more. + */ + try { + Method m0 = f.getClass().getMethod("getInterfaceAddresses"); + for (Object ia : (List)m0.invoke(f)) { + Method m1 = ia.getClass().getMethod("getNetworkPrefixLength"); + Method m2 = ia.getClass().getMethod("getAddress"); + Method m3 = ia.getClass().getMethod("getBroadcast"); + int network_prefix_len = (Short)m1.invoke(ia); + InetAddress address = (InetAddress)m2.invoke(ia); + InetAddress broadcast = (InetAddress)m3.invoke(ia); + if (broadcast == null) broadcast = address; + set.add(new SubNet(network_prefix_len, address, broadcast)); + } + } + catch (Exception x) { + // Java 1.5 or older + // TODO: need a better way to get broadcast addresses on Java 1.5 VM + Enumeration n = f.getInetAddresses(); + while (n.hasMoreElements()) { + InetAddress addr = n.nextElement(); + byte[] buf = addr.getAddress(); + if (buf.length != 4) continue; + buf[3] = (byte)255; + try { + set.add(new SubNet(24, addr, InetAddress.getByAddress(buf))); + } + catch (UnknownHostException y) { + } + } + } + } + } + catch (SocketException x) { + Protocol.log("Cannot get list of network interfaces", x); + } + for (Iterator i = subnets.iterator(); i.hasNext();) { + SubNet s = i.next(); + if (set.contains(s)) continue; + i.remove(); + } + for (Iterator i = set.iterator(); i.hasNext();) { + SubNet s = i.next(); + if (subnets.contains(s)) continue; + subnets.add(s); + } + } + + private void sendPeersRequest(InetAddress addr, int port) { + out_buf[4] = CONF_REQ_INFO; + for (SubNet n : subnets) { + try { + if (addr == null) { + socket.send(new DatagramPacket(out_buf, 8, n.broadcast, DISCOVEY_PORT)); + for (Slave slave : slaves) { + if (!n.contains(slave.address)) continue; + socket.send(new DatagramPacket(out_buf, 8, slave.address, slave.port)); + } + } + else if (n.contains(addr)) { + socket.send(new DatagramPacket(out_buf, 8, addr, port)); + } + } + catch (Exception x) { + Protocol.log("Cannot send datagram packet", x); + } + } + } + + private void sendPeerInfo(IPeer peer, InetAddress addr, int port) { + Map attrs = peer.getAttributes(); + if (attrs.get(IPeer.ATTR_IP_HOST) == null) return; + if (attrs.get(IPeer.ATTR_IP_PORT) == null) return; + try { + out_buf[4] = CONF_PEER_INFO; + int i = 8; + for (String key : attrs.keySet()) { + String s = key + "=" + attrs.get(key); + byte[] bt = s.getBytes("UTF-8"); + if (i + bt.length >= out_buf.length) break; + System.arraycopy(bt, 0, out_buf, i, bt.length); + i += bt.length; + out_buf[i++] = 0; + } + + InetAddress peer_addr = InetAddress.getByName(attrs.get(IPeer.ATTR_IP_HOST)); + for (SubNet subnet : subnets) { + if (peer instanceof RemotePeer) { + if (socket.getLocalPort() != DISCOVEY_PORT) return; + if (!subnet.address.equals(loopback_addr) && !subnet.address.equals(peer_addr)) continue; + } + if (!subnet.address.equals(loopback_addr)) { + if (!subnet.contains(peer_addr)) continue; + } + if (addr == null) { + socket.send(new DatagramPacket(out_buf, i, subnet.broadcast, DISCOVEY_PORT)); + for (Slave slave : slaves) { + if (!subnet.contains(slave.address)) continue; + socket.send(new DatagramPacket(out_buf, i, slave.address, slave.port)); + } + subnet.send_all_ok = true; + } + else if (subnet.contains(addr)) { + socket.send(new DatagramPacket(out_buf, i, addr, port)); + subnet.send_all_ok = true; + } + } + } + catch (Exception x) { + Protocol.log("Cannot send datagram packet", x); + } + } + + private void sendEmptyPacket(InetAddress addr, int port) { + out_buf[4] = CONF_SLAVES_INFO; + for (SubNet n : subnets) { + if (n.send_all_ok) continue; + try { + if (addr == null) { + socket.send(new DatagramPacket(out_buf, 8, n.broadcast, DISCOVEY_PORT)); + for (Slave slave : slaves) { + if (!n.contains(slave.address)) continue; + socket.send(new DatagramPacket(out_buf, 8, slave.address, slave.port)); + } + } + else if (n.contains(addr)) { + socket.send(new DatagramPacket(out_buf, 8, addr, port)); + } + } + catch (Exception x) { + Protocol.log("Cannot send datagram packet", x); + } + } + } + + private void sendAll(InetAddress addr, int port, Slave sl, long time) { + for (SubNet n : subnets) n.send_all_ok = false; + for (IPeer peer : peers.values()) sendPeerInfo(peer, addr, port); + if (addr != null && sl != null && sl.last_req_slaves_time + DATA_RETENTION_PERIOD >= time) { + sendSlavesInfo(addr, port, time); + } + sendEmptyPacket(addr, port); + } + + private void sendSlavesRequest(InetAddress addr, int port) { + try { + out_buf[4] = CONF_REQ_SLAVES; + socket.send(new DatagramPacket(out_buf, 8, addr, port)); + } + catch (Exception x) { + Protocol.log("Cannot send datagram packet", x); + } + } + + private void sendSlaveInfo(Slave x, long time) { + out_buf[4] = CONF_SLAVES_INFO; + for (SubNet n : subnets) { + if (!n.contains(x.address)) continue; + try { + int i = 8; + String s = x.last_packet_time + ":" + x.port + ":" + x.address.getHostAddress(); + byte[] bt = s.getBytes("UTF-8"); + System.arraycopy(bt, 0, out_buf, i, bt.length); + i += bt.length; + out_buf[i++] = 0; + for (Slave y : slaves) { + if (!n.contains(y.address)) continue; + if (y.last_req_slaves_time + DATA_RETENTION_PERIOD < time) continue; + socket.send(new DatagramPacket(out_buf, i, y.address, y.port)); + } + } + catch (Exception z) { + Protocol.log("Cannot send datagram packet", z); + } + } + } + + private void sendSlavesInfo(InetAddress addr, int port, long time) { + out_buf[4] = CONF_SLAVES_INFO; + for (SubNet n : subnets) { + if (!n.contains(addr)) continue; + try { + int i = 8; + for (Slave x : slaves) { + if (x.last_packet_time + DATA_RETENTION_PERIOD < time) continue; + if (x.port == port && x.address.equals(addr)) continue; + if (!n.address.equals(loopback_addr)) { + if (!n.contains(x.address)) continue; + } + n.send_all_ok = true; + String s = x.last_packet_time + ":" + x.port + ":" + x.address.getHostAddress(); + byte[] bt = s.getBytes("UTF-8"); + if (i > 8 && i + bt.length >= PREF_PACKET_SIZE) { + socket.send(new DatagramPacket(out_buf, i, addr, port)); + i = 8; + } + System.arraycopy(bt, 0, out_buf, i, bt.length); + i += bt.length; + out_buf[i++] = 0; + } + if (i > 8) socket.send(new DatagramPacket(out_buf, i, addr, port)); + } + catch (Exception x) { + Protocol.log("Cannot send datagram packet", x); + } + } + } + + private boolean isRemote(InetAddress address, int port) { + if (port != socket.getLocalPort()) return true; + for (SubNet s : subnets) { + if (s.address.equals(address)) return false; + } + return true; + } + + private void handleDatagramPacket(DatagramPacket p) { + try { + long time = System.currentTimeMillis(); + byte[] buf = p.getData(); + int len = p.getLength(); + if (len < 8) return; + if (buf[0] != 'T') return; + if (buf[1] != 'C') return; + if (buf[2] != 'F') return; + if (buf[3] != CONF_VERSION) return; + int remote_port = p.getPort(); + InetAddress remote_address = p.getAddress(); + if (isRemote(remote_address, remote_port)) { + Slave sl = null; + if (p.getPort() != DISCOVEY_PORT) { + sl = addSlave(remote_address, remote_port, time); + } + switch (buf[4]) { + case CONF_PEER_INFO: + handlePeerInfoPacket(p); + break; + case CONF_REQ_INFO: + handleReqInfoPacket(p, sl, time); + break; + case CONF_SLAVES_INFO: + handleSlavesInfoPacket(p); + break; + case CONF_REQ_SLAVES: + handleReqSlavesPacket(p, sl, time); + break; + } + for (SubNet s : subnets) { + if (!s.contains(remote_address)) continue; + long delay = DATA_RETENTION_PERIOD / 3; + if (remote_port != DISCOVEY_PORT) delay = DATA_RETENTION_PERIOD / 3 * 2; + else if (!s.address.equals(remote_address)) delay = DATA_RETENTION_PERIOD / 2; + if (s.last_slaves_req_time + delay <= time) { + sendSlavesRequest(remote_address, remote_port); + s.last_slaves_req_time = time; + } + if (s.address.equals(remote_address) && remote_port == DISCOVEY_PORT) { + last_master_packet_time = time; + } + } + } + } + catch (Throwable x) { + Protocol.log("Invalid datagram packet received", x); + } + } + + private void handlePeerInfoPacket(DatagramPacket p) { + try { + Map map = new HashMap(); + String s = new String(p.getData(), 8, p.getLength() - 8, "UTF-8"); + int l = s.length(); + int i = 0; + while (i < l) { + int i0 = i; + while (i < l && s.charAt(i) != '=' && s.charAt(i) != 0) i++; + int i1 = i; + if (i < l && s.charAt(i) == '=') i++; + int i2 = i; + while (i < l && s.charAt(i) != 0) i++; + int i3 = i; + if (i < l && s.charAt(i) == 0) i++; + String key = s.substring(i0, i1); + String val = s.substring(i2, i3); + map.put(key, val); + } + String id = map.get(IPeer.ATTR_ID); + if (id == null) throw new Exception("Invalid peer info: no ID"); + String peer_host = map.get(IPeer.ATTR_IP_HOST); + if (peer_host == null) return; + InetAddress peer_addr = InetAddress.getByName(peer_host); + for (SubNet subnet : subnets) { + if (!subnet.contains(peer_addr)) continue; + IPeer peer = peers.get(id); + if (peer instanceof RemotePeer) { + ((RemotePeer)peer).updateAttributes(map); + } + else if (peer == null) { + new RemotePeer(map); + } + break; + } + } + catch (Exception x) { + Protocol.log("Invalid datagram packet received", x); + } + } + + private void handleReqInfoPacket(DatagramPacket p, Slave sl, long time) { + sendAll(p.getAddress(), p.getPort(), sl, time); + } + + private void handleSlavesInfoPacket(DatagramPacket p) { + try { + String s = new String(p.getData(), 8, p.getLength() - 8, "UTF-8"); + int l = s.length(); + int i = 0; + while (i < l) { + int time0 = i; + while (i < l&& s.charAt(i) != ':' && s.charAt(i) != 0) i++; + int time1 = i; + if (i < l && s.charAt(i) == ':') i++; + int port0 = i; + while (i < l&& s.charAt(i) != ':' && s.charAt(i) != 0) i++; + int port1 = i; + if (i < l && s.charAt(i) == ':') i++; + int host0 = i; + while (i < l && s.charAt(i) != 0) i++; + int host1 = i; + if (i < l && s.charAt(i) == 0) i++; + int port = Integer.parseInt(s.substring(port0, port1)); + if (port != DISCOVEY_PORT) { + String host = s.substring(host0, host1); + long time = time0 != time1 ? Long.parseLong(s.substring(time0, time1)) : System.currentTimeMillis(); + addSlave(InetAddress.getByName(host), port, time); + } + } + } + catch (Exception x) { + Protocol.log("Invalid datagram packet received", x); + } + } + + private void handleReqSlavesPacket(DatagramPacket p, Slave sl, long time) { + if (sl != null) sl.last_req_slaves_time = time; + sendSlavesInfo(p.getAddress(), p.getPort(), time); + } + + /*----------------------------------------------------------------------------------*/ + + public static LocatorService getLocator() { + return locator; + } + + public String getName() { + return NAME; + } + + public Map getPeers() { + assert Protocol.isDispatchThread(); + return peers; + } + + public IToken redirect(String peer_id, DoneRedirect done) { + throw new Error("Channel redirect cannot be done on local peer"); + } + + public IToken sync(DoneSync done) { + throw new Error("Channel sync cannot be done on local peer"); + } + + public void addListener(LocatorListener listener) { + assert listener != null; + assert Protocol.isDispatchThread(); + listeners.add(listener); + } + + public void removeListener(LocatorListener listener) { + assert Protocol.isDispatchThread(); + listeners.remove(listener); + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/BreakpointsProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/BreakpointsProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,234 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.remote; + +import java.io.IOException; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.tm.tcf.core.Command; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.services.IBreakpoints; + + +public class BreakpointsProxy implements IBreakpoints { + + private final IChannel channel; + private final Map listeners = + new HashMap(); + + public BreakpointsProxy(IChannel channel) { + this.channel = channel; + } + + public IToken set(Map[] properties, final DoneCommand done) { + return new Command(channel, this, "set", new Object[]{ properties }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneCommand(token, error); + } + }.token; + } + + public IToken add(Map properties, final DoneCommand done) { + return new Command(channel, this, "add", new Object[]{ properties }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneCommand(token, error); + } + }.token; + } + + public IToken change(Map properties, final DoneCommand done) { + return new Command(channel, this, "change", new Object[]{ properties }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneCommand(token, error); + } + }.token; + } + + public IToken disable(String[] ids, final DoneCommand done) { + return new Command(channel, this, "disable", new Object[]{ ids }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneCommand(token, error); + } + }.token; + } + + public IToken enable(String[] ids, final DoneCommand done) { + return new Command(channel, this, "enable", new Object[]{ ids }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneCommand(token, error); + } + }.token; + } + + public IToken remove(String[] ids, final DoneCommand done) { + return new Command(channel, this, "remove", new Object[]{ ids }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneCommand(token, error); + } + }.token; + } + + public IToken getIDs(final DoneGetIDs done) { + return new Command(channel, this, "getIDs", null) { + @Override + public void done(Exception error, Object[] args) { + String[] arr = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + arr = toStringArray(args[1]); + } + done.doneGetIDs(token, error, arr); + } + }.token; + } + + public IToken getProperties(String id, final DoneGetProperties done) { + return new Command(channel, this, "getProperties", new Object[]{ id }) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + Map map = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + map = (Map)args[1]; + } + done.doneGetProperties(token, error, map); + } + }.token; + } + + public IToken getStatus(String id, final DoneGetStatus done) { + return new Command(channel, this, "getStatus", new Object[]{ id }) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + Map map = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + map = (Map)args[1]; + } + done.doneGetStatus(token, error, map); + } + }.token; + } + + public IToken getCapabilities(String id, final DoneGetCapabilities done) { + return new Command(channel, this, "getCapabilities", new Object[]{ id }) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + Map map = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + map = (Map)args[1]; + } + done.doneGetCapabilities(token, error, map); + } + }.token; + } + + public String getName() { + return NAME; + } + + @SuppressWarnings("unchecked") + private String[] toStringArray(Object o) { + if (o == null) return null; + Collection c = (Collection)o; + return (String[])c.toArray(new String[c.size()]); + } + + @SuppressWarnings("unchecked") + private Map[] toBreakpointArray(Object o) { + if (o == null) return null; + Collection> c = (Collection>)o; + return (Map[])c.toArray(new Map[c.size()]); + } + + public void addListener(final BreakpointsListener listener) { + IChannel.IEventListener l = new IChannel.IEventListener() { + + @SuppressWarnings("unchecked") + public void event(String name, byte[] data) { + try { + Object[] args = JSON.parseSequence(data); + if (name.equals("status")) { + assert args.length == 2; + listener.breakpointStatusChanged((String)args[0], (Map)args[1]); + } + else if (name.equals("contextAdded")) { + assert args.length == 1; + listener.contextAdded(toBreakpointArray(args[0])); + } + else if (name.equals("contextChanged")) { + assert args.length == 1; + listener.contextChanged(toBreakpointArray(args[0])); + } + else if (name.equals("contextRemoved")) { + assert args.length == 1; + listener.contextRemoved(toStringArray(args[0])); + } + else { + throw new IOException("Breakpoints service: unknown event: " + name); + } + } + catch (Throwable x) { + channel.terminate(x); + } + } + }; + channel.addEventListener(this, l); + listeners.put(listener, l); + } + + public void removeListener(BreakpointsListener listener) { + IChannel.IEventListener l = listeners.remove(listener); + if (l != null) channel.removeEventListener(this, l); + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/DiagnosticsProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/DiagnosticsProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,220 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.remote; + +import java.math.BigDecimal; +import java.util.Collection; +import java.util.Map; + +import org.eclipse.tm.tcf.core.Command; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.services.IDiagnostics; + + +public class DiagnosticsProxy implements IDiagnostics { + + private final IChannel channel; + + private static class Symbol implements ISymbol { + + private final Map props; + + Symbol(Map props) { + this.props = props; + } + + public String getSectionName() { + return (String)props.get("Section"); + } + + public Number getValue() { + return (Number)props.get("Value"); + } + + public boolean isAbs() { + Boolean b = (Boolean)props.get("Abs"); + return b != null && b.booleanValue(); + } + + public boolean isCommon() { + String s = (String)props.get("Storage"); + return s != null && s.equals("COMMON"); + } + + public boolean isGlobal() { + String s = (String)props.get("Storage"); + return s != null && s.equals("GLOBAL"); + } + + public boolean isLocal() { + String s = (String)props.get("Storage"); + return s != null && s.equals("LOCAL"); + } + + public boolean isUndef() { + String s = (String)props.get("Storage"); + return s != null && s.equals("UNDEF"); + } + } + + public DiagnosticsProxy(IChannel channel) { + this.channel = channel; + } + + public String getName() { + return NAME; + } + + public IToken echo(String s, final DoneEcho done) { + return new Command(channel, this, "echo", new Object[]{ s }) { + @Override + public void done(Exception error, Object[] args) { + String str = null; + if (error == null) { + assert args.length == 1; + str = (String)args[0]; + } + done.doneEcho(token, error, str); + } + }.token; + } + + public IToken echoFP(BigDecimal n, final DoneEchoFP done) { + return new Command(channel, this, "echoFP", new Object[]{ n }) { + @Override + public void done(Exception error, Object[] args) { + BigDecimal n = null; + if (error == null) { + assert args.length == 1; + Number x = (Number)args[0]; + if (x instanceof BigDecimal) { + n = (BigDecimal)x; + } + else { + n = new BigDecimal(x.toString()); + } + } + done.doneEchoFP(token, error, n); + } + }.token; + } + + public IToken getTestList(final DoneGetTestList done) { + return new Command(channel, this, "getTestList", null) { + @Override + public void done(Exception error, Object[] args) { + String[] arr = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + arr = toStringArray(args[1]); + } + done.doneGetTestList(token, error, arr); + } + }.token; + } + + public IToken runTest(String s, final DoneRunTest done) { + return new Command(channel, this, "runTest", new Object[]{ s }) { + @Override + public void done(Exception error, Object[] args) { + String str = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + str = (String)args[1]; + } + done.doneRunTest(token, error, str); + } + }.token; + } + + public IToken cancelTest(String s, final DoneCancelTest done) { + return new Command(channel, this, "cancelTest", new Object[]{ s }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneCancelTest(token, error); + } + }.token; + } + + public IToken getSymbol(String context_id, String symbol_name, final DoneGetSymbol done) { + return new Command(channel, this, "getSymbol", new Object[]{ context_id, symbol_name }) { + @Override + public void done(Exception error, Object[] args) { + ISymbol sym = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + sym = toSymbol(args[1]); + } + done.doneGetSymbol(token, error, sym); + } + }.token; + } + + public IToken createTestStreams(int inp_buf_size, int out_buf_size, final DoneCreateTestStreams done) { + return new Command(channel, this, "createTestStreams", new Object[]{ inp_buf_size, out_buf_size }) { + @Override + public void done(Exception error, Object[] args) { + String inp_id = null; + String out_id = null; + if (error == null) { + assert args.length == 3; + error = toError(args[0]); + inp_id = (String)args[1]; + out_id = (String)args[2]; + } + done.doneCreateTestStreams(token, error, inp_id, out_id); + } + }.token; + } + + public IToken disposeTestStream(String id, final DoneDisposeTestStream done) { + return new Command(channel, this, "disposeTestStream", new Object[]{ id }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneDisposeTestStream(token, error); + } + }.token; + } + + public IToken not_implemented_command(final DoneNotImplementedCommand done) { + return new Command(channel, this, "not implemented command", null) { + @Override + public void done(Exception error, Object[] args) { + done.doneNotImplementedCommand(token, error); + } + }.token; + } + + @SuppressWarnings("unchecked") + private String[] toStringArray(Object o) { + if (o == null) return null; + Collection c = (Collection)o; + return (String[])c.toArray(new String[c.size()]); + } + + @SuppressWarnings("unchecked") + private ISymbol toSymbol(Object o) { + if (o == null) return null; + return new Symbol((Map)o); + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/ExpressionsProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/ExpressionsProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,266 @@ +/******************************************************************************* + * Copyright (c) 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.remote; + +import java.io.IOException; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.tm.tcf.core.Command; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.services.IExpressions; +import org.eclipse.tm.tcf.services.ISymbols.TypeClass;; + +public class ExpressionsProxy implements IExpressions { + + private final IChannel channel; + private final Map listeners = + new HashMap(); + + private class Context implements Expression { + + private final Map props; + + Context(Map props) { + this.props = props; + } + + public boolean canAssign() { + Boolean n = (Boolean)props.get(PROP_CAN_ASSIGN); + if (n == null) return false; + return n.booleanValue(); + } + + public int getBits() { + Number n = (Number)props.get(PROP_BITS); + if (n == null) return 0; + return n.intValue(); + } + + public String getExpression() { + return (String)props.get(PROP_EXPRESSION); + } + + public String getID() { + return (String)props.get(PROP_ID); + } + + public String getLanguage() { + return (String)props.get(PROP_LANGUAGE); + } + + public String getParentID() { + return (String)props.get(PROP_PARENT_ID); + } + + public Map getProperties() { + return props; + } + + public int getSize() { + Number n = (Number)props.get(PROP_SIZE); + if (n == null) return 0; + return n.intValue(); + } + + public String getTypeID() { + return (String)props.get(PROP_TYPE); + } + } + + private class ContextValue implements Value { + + private final byte[] value; + private final Map props; + + ContextValue(byte[] value, Map props) { + if (props == null) props = new HashMap(); + this.value = value; + this.props = props; + } + + public Map getProperties() { + return props; + } + + public String getTypeID() { + return (String)props.get(VAL_TYPE); + } + + public String getExeContextID() { + return (String)props.get(VAL_EXE_ID); + } + + public byte[] getValue() { + return value; + } + + public TypeClass getTypeClass() { + Number n = (Number)props.get(VAL_CLASS); + if (n != null) { + switch (n.intValue()) { + case 1: return TypeClass.cardinal; + case 2: return TypeClass.integer; + case 3: return TypeClass.real; + case 4: return TypeClass.pointer; + case 5: return TypeClass.array; + case 6: return TypeClass.composite; + case 7: return TypeClass.enumeration; + case 8: return TypeClass.function; + } + } + return TypeClass.unknown; + } + + public boolean isBigEndian() { + Boolean n = (Boolean)props.get(VAL_BIG_ENDIAN); + if (n == null) return false; + return n.booleanValue(); + } + } + + public ExpressionsProxy(IChannel channel) { + this.channel = channel; + } + + public IToken assign(String id, byte[] value, final DoneAssign done) { + return new Command(channel, this, "assign", new Object[]{ id, new JSON.Binary(value, 0, value.length) }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneAssign(token, error); + } + }.token; + } + + public IToken create(String parent_id, String language, String expression, final DoneCreate done) { + return new Command(channel, this, "create", new Object[]{ parent_id, language, expression }) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + Context ctx = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + if (args[1] != null) ctx = new Context((Map)args[1]); + } + done.doneCreate(token, error, ctx); + } + }.token; + } + + public IToken dispose(String id, final DoneDispose done) { + return new Command(channel, this, "dispose", new Object[]{ id }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneDispose(token, error); + } + }.token; + } + + public IToken evaluate(String id, final DoneEvaluate done) { + return new Command(channel, this, "evaluate", new Object[]{ id }) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + byte[] value = null; + Map props = null; + if (error == null) { + assert args.length == 3; + value = JSON.toByteArray(args[0]); + error = toError(args[1]); + props = (Map)args[2]; + } + done.doneEvaluate(token, error, new ContextValue(value, props)); + } + }.token; + } + + public IToken getChildren(String parent_context_id, final DoneGetChildren done) { + return new Command(channel, this, "getChildren", new Object[]{ parent_context_id }) { + @Override + public void done(Exception error, Object[] args) { + String[] lst = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + lst = toStringArray(args[1]); + } + done.doneGetChildren(token, error, lst); + } + }.token; + } + + public IToken getContext(String id, final DoneGetContext done) { + return new Command(channel, this, "getContext", new Object[]{ id }) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + Context ctx = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + if (args[1] != null) ctx = new Context((Map)args[1]); + } + done.doneGetContext(token, error, ctx); + } + }.token; + } + + public String getName() { + return NAME; + } + + public void addListener(final ExpressionsListener listener) { + IChannel.IEventListener l = new IChannel.IEventListener() { + + public void event(String name, byte[] data) { + try { + Object[] args = JSON.parseSequence(data); + if (name.equals("valueChanged")) { + assert args.length == 1; + listener.valueChanged((String)args[0]); + } + else { + throw new IOException("Expressions service: unknown event: " + name); + } + } + catch (Throwable x) { + channel.terminate(x); + } + } + }; + channel.addEventListener(this, l); + listeners.put(listener, l); + } + + public void removeListener(ExpressionsListener listener) { + IChannel.IEventListener l = listeners.remove(listener); + if (l != null) channel.removeEventListener(this, l); + } + + @SuppressWarnings("unchecked") + private String[] toStringArray(Object o) { + if (o == null) return null; + Collection c = (Collection)o; + return (String[])c.toArray(new String[c.size()]); + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/FileSystemProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/FileSystemProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,595 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.remote; + +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.tm.tcf.core.Command; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IErrorReport; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.services.IFileSystem; + + +public class FileSystemProxy implements IFileSystem { + + private final class FileHandle implements IFileHandle { + final String id; + + FileHandle(String id) { + this.id = id; + } + + public IFileSystem getService() { + return FileSystemProxy.this; + } + + public String toString() { + return "[File Handle '" + id + "']"; + } + } + + private static final class Status extends FileSystemException implements IErrorReport { + + private static final long serialVersionUID = -1636567076145085980L; + + private final int status; + private final Map attrs; + + Status(int status, String message, Map attrs) { + super(message); + this.status = status; + this.attrs = attrs; + } + + Status(Exception x) { + super(x); + this.status = IErrorReport.TCF_ERROR_OTHER; + this.attrs = new HashMap(); + } + + public int getStatus() { + return status; + } + + public int getErrorCode() { + Number n = (Number)attrs.get(ERROR_CODE); + if (n == null) return 0; + return n.intValue(); + } + + public int getAltCode() { + Number n = (Number)attrs.get(ERROR_ALT_CODE); + if (n == null) return 0; + return n.intValue(); + } + + public String getAltOrg() { + return (String)attrs.get(ERROR_ALT_ORG); + } + + public Map getAttributes() { + return attrs; + } + } + + private abstract class FileSystemCommand extends Command { + + FileSystemCommand(String command, Object[] args) { + super(channel, FileSystemProxy.this, command, args); + } + + @SuppressWarnings("unchecked") + public Status toFSError(Object data) { + if (data == null) return null; + Map map = (Map)data; + Number error_code = (Number)map.get(IErrorReport.ERROR_CODE); + String cmd = getCommandString(); + if (cmd.length() > 72) cmd = cmd.substring(0, 72) + "..."; + Status s = new Status(error_code.intValue(), + "TCF command exception:" + + "\nCommand: " + cmd + + "\nException: " + toErrorString(data) + + "\nError code: " + error_code, map); + Object caused_by = map.get(IErrorReport.ERROR_CAUSED_BY); + if (caused_by != null) s.initCause(toError(caused_by, false)); + return s; + } + } + + private final IChannel channel; + + public FileSystemProxy(IChannel channel) { + this.channel = channel; + } + + public IToken close(IFileHandle handle, final DoneClose done) { + assert handle.getService() == this; + String id = ((FileHandle)handle).id; + return new FileSystemCommand("close", new Object[]{ id }) { + public void done(Exception error, Object[] args) { + Status s = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 1; + s = toFSError(args[0]); + } + done.doneClose(token, s); + } + }.token; + } + + public IToken setstat(String path, FileAttrs attrs, final DoneSetStat done) { + Object dt = toObject(attrs); + return new FileSystemCommand("setstat", new Object[]{ path, dt }) { + public void done(Exception error, Object[] args) { + Status s = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 1; + s = toFSError(args[0]); + } + done.doneSetStat(token, s); + } + }.token; + } + + public IToken fsetstat(IFileHandle handle, FileAttrs attrs, final DoneSetStat done) { + assert handle.getService() == this; + String id = ((FileHandle)handle).id; + Object dt = toObject(attrs); + return new FileSystemCommand("fsetstat", new Object[]{ id, dt }) { + public void done(Exception error, Object[] args) { + Status s = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 1; + s = toFSError(args[0]); + } + done.doneSetStat(token, s); + } + }.token; + } + + public IToken stat(String path, final DoneStat done) { + return new FileSystemCommand("stat", new Object[]{ path }) { + public void done(Exception error, Object[] args) { + Status s = null; + FileAttrs a = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 2; + s = toFSError(args[0]); + if (s == null) a = toFileAttrs(args[1]); + } + done.doneStat(token, s, a); + } + }.token; + } + + public IToken fstat(IFileHandle handle, final DoneStat done) { + assert handle.getService() == this; + String id = ((FileHandle)handle).id; + return new FileSystemCommand("fstat", new Object[]{ id }) { + public void done(Exception error, Object[] args) { + Status s = null; + FileAttrs a = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 2; + s = toFSError(args[0]); + if (s == null) a = toFileAttrs(args[1]); + } + done.doneStat(token, s, a); + } + }.token; + } + + public IToken lstat(String path, final DoneStat done) { + return new FileSystemCommand("lstat", new Object[]{ path }) { + public void done(Exception error, Object[] args) { + Status s = null; + FileAttrs a = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 2; + s = toFSError(args[0]); + if (s == null) a = toFileAttrs(args[1]); + } + done.doneStat(token, s, a); + } + }.token; + } + + public IToken mkdir(String path, FileAttrs attrs, final DoneMkDir done) { + Object dt = toObject(attrs); + return new FileSystemCommand("mkdir", new Object[]{ path, dt }) { + public void done(Exception error, Object[] args) { + Status s = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 1; + s = toFSError(args[0]); + } + done.doneMkDir(token, s); + } + }.token; + } + + public IToken open(String file_name, int flags, FileAttrs attrs, final DoneOpen done) { + Object dt = toObject(attrs); + return new FileSystemCommand("open", new Object[]{ file_name, new Integer(flags), dt }) { + public void done(Exception error, Object[] args) { + Status s = null; + FileHandle h = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 2; + s = toFSError(args[0]); + if (s == null) h = toFileHandle(args[1]); + } + done.doneOpen(token, s, h); + } + }.token; + } + + public IToken opendir(String path, final DoneOpen done) { + return new FileSystemCommand("opendir", new Object[]{ path }) { + public void done(Exception error, Object[] args) { + Status s = null; + FileHandle h = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 2; + s = toFSError(args[0]); + if (s == null) h = toFileHandle(args[1]); + } + done.doneOpen(token, s, h); + } + }.token; + } + + public IToken read(IFileHandle handle, long offset, int len, final DoneRead done) { + assert handle.getService() == this; + String id = ((FileHandle)handle).id; + return new FileSystemCommand("read", new Object[]{ + id, Long.valueOf(offset), Integer.valueOf(len) }) { + public void done(Exception error, Object[] args) { + Status s = null; + byte[] b = null; + boolean eof = false; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 3; + s = toFSError(args[1]); + if (s == null) { + b = JSON.toByteArray(args[0]); + eof = ((Boolean)args[2]).booleanValue(); + } + } + done.doneRead(token, s, b, eof); + } + }.token; + } + + public IToken readdir(IFileHandle handle, final DoneReadDir done) { + assert handle.getService() == this; + String id = ((FileHandle)handle).id; + return new FileSystemCommand("readdir", new Object[]{ id }) { + public void done(Exception error, Object[] args) { + Status s = null; + DirEntry[] b = null; + boolean eof = false; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 3; + s = toFSError(args[1]); + if (s == null) { + b = toDirEntryArray(args[0]); + eof = ((Boolean)args[2]).booleanValue(); + } + } + done.doneReadDir(token, s, b, eof); + } + }.token; + } + + public IToken roots(final DoneRoots done) { + return new FileSystemCommand("roots", null) { + public void done(Exception error, Object[] args) { + Status s = null; + DirEntry[] b = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 2; + s = toFSError(args[1]); + if (s == null) b = toDirEntryArray(args[0]); + } + done.doneRoots(token, s, b); + } + }.token; + } + + public IToken readlink(String path, final DoneReadLink done) { + return new FileSystemCommand("readlink", new Object[]{ path }) { + public void done(Exception error, Object[] args) { + Status s = null; + String p = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 2; + s = toFSError(args[0]); + if (s == null) p = (String)args[1]; + } + done.doneReadLink(token, s, p); + } + }.token; + } + + public IToken realpath(String path, final DoneRealPath done) { + return new FileSystemCommand("realpath", new Object[]{ path }) { + public void done(Exception error, Object[] args) { + Status s = null; + String p = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 2; + s = toFSError(args[0]); + if (s == null) p = (String)args[1]; + } + done.doneRealPath(token, s, p); + } + }.token; + } + + public IToken remove(String file_name, final DoneRemove done) { + return new FileSystemCommand("remove", new Object[]{ file_name }) { + public void done(Exception error, Object[] args) { + Status s = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 1; + s = toFSError(args[0]); + } + done.doneRemove(token, s); + } + }.token; + } + + public IToken rename(String old_path, String new_path, final DoneRename done) { + return new FileSystemCommand("rename", new Object[]{ old_path, new_path }) { + public void done(Exception error, Object[] args) { + Status s = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 1; + s = toFSError(args[0]); + } + done.doneRename(token, s); + } + }.token; + } + + public IToken rmdir(String path, final DoneRemove done) { + return new FileSystemCommand("rmdir", new Object[]{ path }) { + public void done(Exception error, Object[] args) { + Status s = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 1; + s = toFSError(args[0]); + } + done.doneRemove(token, s); + } + }.token; + } + + public IToken symlink(String link_path, String target_path, final DoneSymLink done) { + return new FileSystemCommand("symlink", new Object[]{ link_path, target_path }) { + public void done(Exception error, Object[] args) { + Status s = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 1; + s = toFSError(args[0]); + } + done.doneSymLink(token, s); + } + }.token; + } + + public IToken write(IFileHandle handle, long offset, byte[] data, + int data_pos, int data_size, final DoneWrite done) { + assert handle.getService() == this; + String id = ((FileHandle)handle).id; + return new FileSystemCommand("write", new Object[]{ + id, Long.valueOf(offset), new JSON.Binary(data, data_pos, data_size) }) { + public void done(Exception error, Object[] args) { + Status s = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 1; + s = toFSError(args[0]); + } + done.doneWrite(token, s); + } + }.token; + } + + public IToken copy(String src_path, String dst_path, + boolean copy_permissions, boolean copy_uidgid, final DoneCopy done) { + return new FileSystemCommand("copy", new Object[]{ + src_path, dst_path, Boolean.valueOf(copy_permissions), + Boolean.valueOf(copy_uidgid) }) { + public void done(Exception error, Object[] args) { + Status s = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 1; + s = toFSError(args[0]); + } + done.doneCopy(token, s); + } + }.token; + } + + public IToken user(final DoneUser done) { + return new FileSystemCommand("user", null) { + @Override + public void done(Exception error, Object[] args) { + Status s = null; + int r_uid = 0; + int e_uid = 0; + int r_gid = 0; + int e_gid = 0; + String home = null; + if (error != null) { + s = new Status(error); + } + else { + assert args.length == 5; + r_uid = ((Number)args[0]).intValue(); + e_uid = ((Number)args[1]).intValue(); + r_gid = ((Number)args[2]).intValue(); + e_gid = ((Number)args[3]).intValue(); + home = (String)args[4]; + } + done.doneUser(token, s, r_uid, e_uid, r_gid, e_gid, home); + } + }.token; + } + + public String getName() { + return NAME; + } + + private Object toObject(FileAttrs attrs) { + if (attrs == null) return null; + Map m = new HashMap(); + if (attrs.attributes != null) m.putAll(attrs.attributes); + if ((attrs.flags & ATTR_SIZE) != 0) { + m.put("Size", Long.valueOf(attrs.size)); + } + if ((attrs.flags & ATTR_UIDGID) != 0) { + m.put("UID", Integer.valueOf(attrs.uid)); + m.put("GID", Integer.valueOf(attrs.gid)); + } + if ((attrs.flags & ATTR_PERMISSIONS) != 0) { + m.put("Permissions", Integer.valueOf(attrs.permissions)); + } + if ((attrs.flags & ATTR_ACMODTIME) != 0) { + m.put("ATime", Long.valueOf(attrs.atime)); + m.put("MTime", Long.valueOf(attrs.mtime)); + } + return m; + } + + @SuppressWarnings("unchecked") + private FileAttrs toFileAttrs(Object o) { + if (o == null) return null; + Map m = new HashMap((Map)o); + int flags = 0; + long size = 0; + int uid = 0; + int gid = 0; + int permissions = 0; + long atime = 0; + long mtime = 0; + Number n = (Number)m.remove("Size"); + if (n != null) { + size = n.longValue(); + flags |= ATTR_SIZE; + } + Number n1 = (Number)m.remove("UID"); + Number n2 = (Number)m.remove("GID"); + if (n1 != null && n2 != null) { + uid = n1.intValue(); + gid = n2.intValue(); + flags |= ATTR_UIDGID; + } + n = (Number)m.remove("Permissions"); + if (n != null) { + permissions = n.intValue(); + flags |= ATTR_PERMISSIONS; + } + n1 = (Number)m.remove("ATime"); + n2 = (Number)m.remove("MTime"); + if (n1 != null && n2 != null) { + atime = n1.longValue(); + mtime = n2.longValue(); + flags |= ATTR_ACMODTIME; + } + return new FileAttrs(flags, size, uid, gid, permissions, atime, mtime, m); + } + + private FileHandle toFileHandle(Object o) { + if (o == null) return null; + return new FileHandle(o.toString()); + } + + @SuppressWarnings("unchecked") + private DirEntry[] toDirEntryArray(Object o) { + if (o == null) return null; + Collection> c = (Collection>)o; + DirEntry[] res = new DirEntry[c.size()]; + int i = 0; + for (Map m : c) { + res[i++] = new DirEntry( + (String)m.get("FileName"), + (String)m.get("LongName"), + toFileAttrs(m.get("Attrs"))); + } + return res; + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/GenericProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/GenericProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,39 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.remote; + +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IService; + +/** + * Objects of GenericProxy class represent remote services, which don't + * have a proxy class defined for them. + * Clients still can use such services, but framework will not provide + * service specific utility methods for message formatting and parsing. + */ +public class GenericProxy implements IService { + + private final IChannel channel; + private final String name; + + public GenericProxy(IChannel channel, String name) { + this.channel = channel; + this.name = name; + } + + public String getName() { + return name; + } + + public IChannel getChannel() { + return channel; + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/LineNumbersProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/LineNumbersProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,80 @@ +package org.eclipse.tm.internal.tcf.services.remote; + +import java.util.Collection; +import java.util.Map; + +import org.eclipse.tm.tcf.core.Command; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.services.ILineNumbers; + + +public class LineNumbersProxy implements ILineNumbers { + + private final IChannel channel; + + public LineNumbersProxy(IChannel channel) { + this.channel = channel; + } + + public String getName() { + return NAME; + } + + public IToken mapToSource(String context_id, Number start_address, + Number end_address, final DoneMapToSource done) { + return new Command(channel, this, "mapToSource", new Object[]{ context_id, + start_address, end_address }) { + @Override + public void done(Exception error, Object[] args) { + CodeArea[] arr = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + arr = toTextAreaArray(args[1]); + } + done.doneMapToSource(token, error, arr); + } + }.token; + } + + private static int getInteger(Map map, String name, int def) { + Number n = (Number)map.get(name); + if (n == null) return def; + return n.intValue(); + } + + private static String getString(Map map, String name, String def) { + String s = (String)map.get(name); + if (s == null) return def; + return s; + } + + private static boolean getBoolean(Map map, String name) { + Boolean b = (Boolean)map.get(name); + if (b == null) return false; + return b.booleanValue(); + } + + @SuppressWarnings("unchecked") + private CodeArea[] toTextAreaArray(Object o) { + if (o == null) return null; + Collection> c = (Collection>)o; + int n = 0; + CodeArea[] arr = new CodeArea[c.size()]; + String directory = null; + String file = null; + for (Map area : c) { + directory = getString(area, "Dir", directory); + file = getString(area, "File", file); + arr[n++] = new CodeArea(directory, file, + getInteger(area, "SLine", 0), getInteger(area, "SCol", 0), + getInteger(area, "ELine", 0), getInteger(area, "ECol", 0), + (Number)area.get("SAddr"), (Number)area.get("EAddr"), + getInteger(area, "ISA", 0), + getBoolean(area, "IsStmt"), getBoolean(area, "BasicBlock"), + getBoolean(area, "PrologueEnd"), getBoolean(area, "EpilogueBegin")); + } + return arr; + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/LocatorProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/LocatorProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,235 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.remote; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.tm.tcf.core.Command; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IPeer; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.protocol.Protocol; +import org.eclipse.tm.tcf.services.ILocator; + + +public class LocatorProxy implements ILocator { + + private final IChannel channel; + private final Map peers = new HashMap(); + private final Collection listeners = new ArrayList(); + + private boolean get_peers_done = false; + + private class Peer implements IPeer { + + private final IPeer parent; + + private final Map attrs; + + Peer(IPeer parent, Map attrs) { + this.parent = parent; + this.attrs = attrs; + } + + public Map getAttributes() { + assert Protocol.isDispatchThread(); + return attrs; + } + + public String getID() { + assert Protocol.isDispatchThread(); + return attrs.get(ATTR_ID); + } + + public String getName() { + assert Protocol.isDispatchThread(); + return attrs.get(ATTR_NAME); + } + + public String getOSName() { + assert Protocol.isDispatchThread(); + return attrs.get(ATTR_OS_NAME); + } + + public String getTransportName() { + assert Protocol.isDispatchThread(); + return attrs.get(ATTR_TRANSPORT_NAME); + } + + public IChannel openChannel() { + assert Protocol.isDispatchThread(); + IChannel c = parent.openChannel(); + c.redirect(getID()); + return c; + } + }; + + private final IChannel.IEventListener event_listener = new IChannel.IEventListener() { + + @SuppressWarnings("unchecked") + public void event(String name, byte[] data) { + try { + Object[] args = JSON.parseSequence(data); + if (name.equals("peerAdded")) { + assert args.length == 1; + IPeer peer = new Peer(channel.getRemotePeer(), (Map)args[0]); + if (peers.get(peer.getID()) != null) { + Protocol.log("Invalid peerAdded event", new Error()); + return; + } + peers.put(peer.getID(), peer); + for (LocatorListener l : listeners.toArray(new LocatorListener[listeners.size()])) { + try { + l.peerAdded(peer); + } + catch (Throwable x) { + Protocol.log("Unhandled exception in Locator listener", x); + } + } + } + else if (name.equals("peerChanged")) { + assert args.length == 1; + Map m = (Map)args[0]; + if (m == null) throw new Error("Locator service: invalid peerChanged event - no peer ID"); + IPeer peer = peers.get(m.get(IPeer.ATTR_ID)); + if (peer == null) return; + peers.put(peer.getID(), peer); + for (LocatorListener l : listeners.toArray(new LocatorListener[listeners.size()])) { + try { + l.peerChanged(peer); + } + catch (Throwable x) { + Protocol.log("Unhandled exception in Locator listener", x); + } + } + } + else if (name.equals("peerRemoved")) { + assert args.length == 1; + String id = (String)args[0]; + IPeer peer = peers.remove(id); + if (peer == null) return; + for (LocatorListener l : listeners.toArray(new LocatorListener[listeners.size()])) { + try { + l.peerRemoved(id); + } + catch (Throwable x) { + Protocol.log("Unhandled exception in Locator listener", x); + } + } + } + else if (name.equals("peerHeartBeat")) { + assert args.length == 1; + String id = (String)args[0]; + IPeer peer = peers.get(id); + if (peer == null) return; + for (LocatorListener l : listeners.toArray(new LocatorListener[listeners.size()])) { + try { + l.peerHeartBeat(id); + } + catch (Throwable x) { + Protocol.log("Unhandled exception in Locator listener", x); + } + } + } + else { + throw new IOException("Locator service: unknown event: " + name); + } + } + catch (Throwable x) { + channel.terminate(x); + } + } + }; + + public LocatorProxy(IChannel channel) { + this.channel = channel; + channel.addEventListener(this, event_listener); + } + + public String getName() { + return NAME; + } + + public Map getPeers() { + return peers; + } + + public IToken redirect(String peer_id, final DoneRedirect done) { + return new Command(channel, this, "redirect", new Object[]{ peer_id }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneRedirect(token, error); + } + }.token; + } + + public IToken sync(final DoneSync done) { + return new Command(channel, this, "sync", null) { + @Override + public void done(Exception error, Object[] args) { + if (error != null) channel.terminate(error); + done.doneSync(token); + } + }.token; + } + + public void addListener(LocatorListener listener) { + listeners.add(listener); + if (!get_peers_done) { + new Command(channel, this, "getPeers", null) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + } + if (error != null) { + Protocol.log("Locator error", error); + return; + } + Collection c = (Collection)args[1]; + if (c != null) { + for (Object o : c) { + Map m = (Map)o; + String id = m.get(IPeer.ATTR_ID); + if (peers.get(id) != null) continue; + IPeer peer = new Peer(channel.getRemotePeer(), m); + peers.put(id, peer); + for (LocatorListener l : listeners.toArray(new LocatorListener[listeners.size()])) { + try { + l.peerAdded(peer); + } + catch (Throwable x) { + Protocol.log("Unhandled exception in Locator listener", x); + } + } + } + } + } + }; + get_peers_done = true; + } + } + + public void removeListener(LocatorListener listener) { + listeners.remove(listener); + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/MemoryProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/MemoryProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,407 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.remote; + +import java.io.IOException; +import java.math.BigInteger; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; + +import org.eclipse.tm.tcf.core.Command; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IErrorReport; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.services.IMemory; + + +public class MemoryProxy implements IMemory { + + private final IChannel channel; + private final Map listeners = + new HashMap(); + + private static class Range implements Comparable { + int offs; + int size; + int stat; + String msg; + + public int compareTo(Range o) { + if (offs < o.offs) return -1; + if (offs > o.offs) return +1; + return 0; + } + } + + private class MemoryErrorReport extends MemoryError implements ErrorOffset, IErrorReport { + + private static final long serialVersionUID = 796525409870265390L; + private final Map attrs; + private final Range[] ranges; + + @SuppressWarnings("unchecked") + MemoryErrorReport(String msg, Map attrs, Number addr, Object ranges) { + super(msg); + this.attrs = attrs; + Collection> c = (Collection>)ranges; + this.ranges = c == null ? null : new Range[c.size()]; + if (c != null) { + int n = 0; + BigInteger addr_bi = addr instanceof BigInteger ? + (BigInteger)addr : new BigInteger(addr.toString()); + for (Map m : c) { + Range r = new Range(); + Number x = (Number)m.get("addr"); + BigInteger y = x instanceof BigInteger ? + (BigInteger)x : new BigInteger(x.toString()); + r.offs = addr_bi.subtract(y).intValue(); + r.size = ((Number)m.get("size")).intValue(); + r.stat = ((Number)m.get("stat")).intValue(); + r.msg = Command.toErrorString(m.get("msg")); + assert r.offs >= 0; + assert r.size >= 0; + this.ranges[n++] = r; + } + Arrays.sort(this.ranges); + } + } + + public int getErrorCode() { + Number n = (Number)attrs.get(ERROR_CODE); + if (n == null) return 0; + return n.intValue(); + } + + public int getAltCode() { + Number n = (Number)attrs.get(ERROR_ALT_CODE); + if (n == null) return 0; + return n.intValue(); + } + + public String getAltOrg() { + return (String)attrs.get(ERROR_ALT_ORG); + } + + public Map getAttributes() { + return attrs; + } + + public String getMessage(int offset) { + if (ranges == null) return null; + int l = 0; + int h = ranges.length - 1; + while (l <= h) { + int n = (l + h) / 2; + Range r = ranges[n]; + if (r.offs > offset) { + h = n - 1; + } + else if (offset >= r.offs + r.size) { + l = n + 1; + } + else { + return r.msg; + } + } + return null; + } + + public int getStatus(int offset) { + if (ranges == null) return BYTE_UNKNOWN; + int l = 0; + int h = ranges.length - 1; + while (l <= h) { + int n = (l + h) / 2; + Range r = ranges[n]; + if (r.offs > offset) { + h = n - 1; + } + else if (offset >= r.offs + r.size) { + l = n + 1; + } + else { + return r.stat; + } + } + return BYTE_UNKNOWN; + } + } + + private class MemContext implements MemoryContext { + + private final Map props; + + MemContext(Map props) { + this.props = props; + } + + public String getID() { + return (String)props.get(PROP_ID); + } + + public String getParentID() { + return (String)props.get(PROP_PARENT_ID); + } + + public int getAddressSize() { + Number n = (Number)props.get(PROP_ADDRESS_SIZE); + if (n == null) return 0; + return n.intValue(); + } + + public String getProcessID() { + return (String)props.get(PROP_PROCESS_ID); + } + + public boolean isBigEndian() { + Boolean n = (Boolean)props.get(PROP_BIG_ENDIAN); + if (n == null) return false; + return n.booleanValue(); + } + + @SuppressWarnings("unchecked") + public Collection getAccessTypes() { + return (Collection)props.get(PROP_ACCESS_TYPES); + } + + public Number getEndBound() { + return (Number)props.get(PROP_END_BOUND); + } + + public String getName() { + return (String)props.get(PROP_NAME); + } + + public Number getStartBound() { + return (Number)props.get(PROP_START_BOUND); + } + + public Map getProperties() { + return props; + } + + public IToken fill(final Number addr, int word_size, + byte[] value, int size, int mode, final DoneMemory done) { + return new MemoryCommand("fill", new Object[] { + getID(), addr, word_size, size, mode, value + } ) { + public void done(Exception error, Object[] args) { + MemoryError e = null; + if (error != null) { + e = new MemoryError(error.getMessage()); + } + else { + assert args.length == 2; + e = toMemoryError(addr, args[0], args[1]); + } + done.doneMemory(token, e); + } + }.token; + } + + public IToken get(final Number addr, int word_size, + final byte[] buf, final int offs, final int size, + int mode, final DoneMemory done) { + return new MemoryCommand("get", new Object[] { + getID(), addr, word_size, size, mode + } ) { + public void done(Exception error, Object[] args) { + MemoryError e = null; + if (error != null) { + e = new MemoryError(error.getMessage()); + } + else { + assert args.length == 3; + JSON.toByteArray(buf, offs, size, args[0]); + e = toMemoryError(addr, args[1], args[2]); + } + done.doneMemory(token, e); + } + }.token; + } + + public IToken set(final Number addr, int word_size, + byte[] buf, int offs, int size, int mode, final DoneMemory done) { + return new MemoryCommand("set", new Object[] { + getID(), addr, word_size, size, mode, new JSON.Binary(buf, offs, size) + } ) { + public void done(Exception error, Object[] args) { + MemoryError e = null; + if (error != null) { + e = new MemoryError(error.getMessage()); + } + else { + assert args.length == 2; + e = toMemoryError(addr, args[0], args[1]); + } + done.doneMemory(token, e); + } + }.token; + } + + public String toString() { + return "[Memory Context " + props.toString() + "]"; + } + } + + public MemoryProxy(IChannel channel) { + this.channel = channel; + } + + public void addListener(final MemoryListener listener) { + IChannel.IEventListener l = new IChannel.IEventListener() { + + public void event(String name, byte[] data) { + try { + Object[] args = JSON.parseSequence(data); + if (name.equals("contextAdded")) { + assert args.length == 1; + listener.contextAdded(toContextArray(args[0])); + } + else if (name.equals("contextChanged")) { + assert args.length == 1; + listener.contextChanged(toContextArray(args[0])); + } + else if (name.equals("contextRemoved")) { + assert args.length == 1; + listener.contextRemoved(toStringArray(args[0])); + } + else if (name.equals("memoryChanged")) { + assert args.length == 2; + listener.memoryChanged((String)args[0], + toAddrArray(args[1]), toSizeArray(args[1])); + } + else { + throw new IOException("Memory service: unknown event: " + name); + } + } + catch (Throwable x) { + channel.terminate(x); + } + } + }; + channel.addEventListener(this, l); + listeners.put(listener, l); + } + + public void removeListener(MemoryListener listener) { + IChannel.IEventListener l = listeners.remove(listener); + if (l != null) channel.removeEventListener(this, l); + } + + public IToken getContext(String context_id, final DoneGetContext done) { + return new Command(channel, this, "getContext", new Object[]{ context_id }) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + MemContext ctx = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + if (args[1] != null) ctx = new MemContext((Map)args[1]); + } + done.doneGetContext(token, error, ctx); + } + }.token; + } + + public IToken getChildren(String parent_context_id, final DoneGetChildren done) { + return new Command(channel, this, "getChildren", new Object[]{ parent_context_id }) { + @Override + public void done(Exception error, Object[] args) { + String[] arr = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + arr = toStringArray(args[1]); + } + done.doneGetChildren(token, error, arr); + } + }.token; + } + + public String getName() { + return NAME; + } + + private abstract class MemoryCommand extends Command { + + MemoryCommand(String cmd, Object[] args) { + super(channel, MemoryProxy.this, cmd, args); + } + + @SuppressWarnings("unchecked") + MemoryError toMemoryError(Number addr, Object data, Object ranges) { + if (data == null) return null; + Map map = (Map)data; + Integer code = (Integer)map.get(IErrorReport.ERROR_CODE); + String cmd = getCommandString(); + if (cmd.length() > 72) cmd = cmd.substring(0, 72) + "..."; + MemoryError e = new MemoryErrorReport( + "TCF command exception:" + + "\nCommand: " + cmd + + "\nException: " + toErrorString(data) + + "\nError code: " + code, + map, addr, ranges); + Object caused_by = map.get(IErrorReport.ERROR_CAUSED_BY); + if (caused_by != null) e.initCause(toError(caused_by, false)); + return e; + } + } + + @SuppressWarnings("unchecked") + private MemoryContext[] toContextArray(Object o) { + Collection> c = (Collection>)o; + if (c == null) return new MemoryContext[0]; + int n = 0; + MemoryContext[] ctx = new MemoryContext[c.size()]; + for (Iterator> i = c.iterator(); i.hasNext();) { + ctx[n++] = new MemContext(i.next()); + } + return ctx; + } + + @SuppressWarnings("unchecked") + private long[] toSizeArray(Object o) { + Collection> c = (Collection>)o; + if (c == null) return null; + long[] a = new long[c.size()]; + int n = 0; + for (Map m : c) { + Number sz = (Number)m.get("size"); + a[n++] = sz == null ? 0 : sz.longValue(); + } + return a; + } + + @SuppressWarnings("unchecked") + private Number[] toAddrArray(Object o) { + Collection> c = (Collection>)o; + if (c == null) return null; + Number[] a = new Number[c.size()]; + int n = 0; + for (Map m : c) { + a[n++] = (Number)m.get("addr"); + } + return a; + } + + @SuppressWarnings("unchecked") + private String[] toStringArray(Object o) { + if (o == null) return null; + Collection c = (Collection)o; + return (String[])c.toArray(new String[c.size()]); + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/ProcessesProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/ProcessesProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,315 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.remote; + +import java.io.IOException; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.tm.tcf.core.Command; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.services.IProcesses; + + +public class ProcessesProxy implements IProcesses { + + private final IChannel channel; + private final Map listeners = + new HashMap(); + + private class ProcessContext implements IProcesses.ProcessContext { + + private final Map props; + + ProcessContext(Map props) { + this.props = props; + } + + public String getID() { + return (String)props.get(PROP_ID); + } + + public String getParentID() { + return (String)props.get(PROP_PARENTID); + } + + public boolean canTerminate() { + Boolean b = (Boolean)props.get(PROP_CAN_TERMINATE); + return b != null && b.booleanValue(); + } + + public String getName() { + return (String)props.get(PROP_NAME); + } + + public boolean isAttached() { + Boolean b = (Boolean)props.get(PROP_ATTACHED); + return b != null && b.booleanValue(); + } + + public IToken attach(final DoneCommand done) { + return new Command(channel, ProcessesProxy.this, + "attach", new Object[]{ getID() }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneCommand(token, error); + } + }.token; + } + + public IToken detach(final DoneCommand done) { + return new Command(channel, ProcessesProxy.this, + "detach", new Object[]{ getID() }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneCommand(token, error); + } + }.token; + } + + public IToken terminate(final DoneCommand done) { + return new Command(channel, ProcessesProxy.this, + "terminate", new Object[]{ getID() }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneCommand(token, error); + } + }.token; + } + + public Map getProperties() { + return props; + } + + public String toString() { + return "[Processes Context " + props.toString() + "]"; + } + } + + public ProcessesProxy(IChannel channel) { + this.channel = channel; + } + + public String getName() { + return NAME; + } + + public void addListener(final ProcessesListener listener) { + IChannel.IEventListener l = new IChannel.IEventListener() { + + public void event(String name, byte[] data) { + try { + Object[] args = JSON.parseSequence(data); + if (name.equals("exited")) { + assert args.length == 2; + listener.exited((String)args[0], ((Number)args[1]).intValue()); + } + else { + throw new IOException("Processes service: unknown event: " + name); + } + } + catch (Throwable x) { + channel.terminate(x); + } + } + }; + channel.addEventListener(this, l); + listeners.put(listener, l); + } + + public void removeListener(ProcessesListener listener) { + IChannel.IEventListener l = listeners.remove(listener); + if (l != null) channel.removeEventListener(this, l); + } + + public IToken getChildren(String parent_context_id, boolean attached_only, final DoneGetChildren done) { + return new Command(channel, this, + "getChildren", new Object[]{ parent_context_id, attached_only }) { + @Override + public void done(Exception error, Object[] args) { + String[] ids = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + ids = toStringArray(args[1]); + } + done.doneGetChildren(token, error, ids); + } + }.token; + } + + public IToken getContext(String id, final DoneGetContext done) { + return new Command(channel, this, + "getContext", new Object[]{ id }) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + ProcessContext ctx = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + if (args[1] != null) ctx = new ProcessContext((Map)args[1]); + } + done.doneGetContext(token, error, ctx); + } + }.token; + } + + public IToken getEnvironment(final DoneGetEnvironment done) { + return new Command(channel, this, "getEnvironment", null) { + @Override + public void done(Exception error, Object[] args) { + Map env = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + env = toEnvMap(args[1]); + } + done.doneGetEnvironment(token, error, env); + } + }.token; + } + + public IToken start(String directory, String file, + String[] command_line, Map environment, + boolean attach, final DoneStart done) { + return new Command(channel, this, + "start", new Object[]{ directory, file, command_line, + toEnvStringArray(environment), attach }) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + ProcessContext ctx = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + if (args[1] != null) ctx = new ProcessContext((Map)args[1]); + } + done.doneStart(token, error, ctx); + } + }.token; + } + + public IToken getSignalList(String context_id, final DoneGetSignalList done) { + return new Command(channel, ProcessesProxy.this, + "getSignalList", new Object[]{ context_id }) { + @Override + public void done(Exception error, Object[] args) { + Collection> list = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + list = toSignalList(args[1]); + } + done.doneGetSignalList(token, error, list); + } + }.token; + } + + public IToken getSignalMask(String context_id, final DoneGetSignalMask done) { + return new Command(channel, ProcessesProxy.this, + "getSignalMask", new Object[]{ context_id }) { + @Override + public void done(Exception error, Object[] args) { + int dont_stop = 0; + int dont_pass = 0; + int pending = 0; + if (error == null) { + assert args.length == 4; + error = toError(args[0]); + if (args[1] != null) dont_stop = ((Number)args[1]).intValue(); + if (args[2] != null) dont_pass = ((Number)args[2]).intValue(); + if (args[3] != null) pending = ((Number)args[3]).intValue(); + } + done.doneGetSignalMask(token, error, dont_stop, dont_pass, pending); + } + }.token; + } + + public IToken setSignalMask(String context_id, int dont_stop, int dont_pass, final DoneCommand done) { + return new Command(channel, ProcessesProxy.this, + "setSignalMask", new Object[]{ context_id, dont_stop, dont_pass }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneCommand(token, error); + } + }.token; + } + + public IToken signal(String context_id, long signal, final DoneCommand done) { + return new Command(channel, ProcessesProxy.this, + "signal", new Object[]{ context_id, signal }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneCommand(token, error); + } + }.token; + } + + @SuppressWarnings("unchecked") + private static String[] toStringArray(Object o) { + if (o == null) return null; + Collection c = (Collection)o; + return (String[])c.toArray(new String[c.size()]); + } + + private static String[] toEnvStringArray(Map m) { + if (m == null) return new String[0]; + int n = 0; + String[] arr = new String[m.size()]; + for (String s : m.keySet()) { + arr[n++] = s + "=" + m.get(s); + } + return arr; + } + + @SuppressWarnings("unchecked") + private static Map toEnvMap(Object o) { + Map m = new HashMap(); + if (o == null) return m; + Collection c = (Collection)o; + for (String s : c) { + int i = s.indexOf('='); + if (i >= 0) m.put(s.substring(0, i), s.substring(i + 1)); + else m.put(s, ""); + } + return m; + } + + @SuppressWarnings("unchecked") + private static Collection> toSignalList(Object o) { + if (o == null) return null; + return (Collection>)o; + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/RegistersProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/RegistersProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,385 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.remote; + +import java.io.IOException; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.tm.tcf.core.Command; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.services.IRegisters; + + +public class RegistersProxy implements IRegisters { + + private final IChannel channel; + private final Map listeners = + new HashMap(); + + private class Context implements RegistersContext { + + private final Map props; + + Context(Map props) { + this.props = props; + } + + public int[] getBitNumbers() { + return toIntArray(props.get(PROP_BITS)); + } + + public String getDescription() { + return (String)props.get(PROP_DESCRIPTION); + } + + public int getFirstBitNumber() { + Number n = (Number)props.get(PROP_FIST_BIT); + if (n == null) return 0; + return n.intValue(); + } + + public String getID() { + return (String)props.get(PROP_ID); + } + + public String getName() { + return (String)props.get(PROP_NAME); + } + + public NamedValue[] getNamedValues() { + return toValuesArray(props.get(PROP_VALUES)); + } + + public String getParentID() { + return (String)props.get(PROP_PARENT_ID); + } + + public int getSize() { + Number n = (Number)props.get(PROP_SIZE); + if (n == null) return 0; + return n.intValue(); + } + + public Map getProperties() { + return props; + } + + public boolean hasSideEffects() { + Boolean n = (Boolean)props.get(PROP_SIDE_EFFECTS); + if (n == null) return false; + return n.booleanValue(); + } + + public boolean isBigEndian() { + Boolean n = (Boolean)props.get(PROP_BIG_ENDIAN); + if (n == null) return false; + return n.booleanValue(); + } + + public boolean isFloat() { + Boolean n = (Boolean)props.get(PROP_FLOAT); + if (n == null) return false; + return n.booleanValue(); + } + + public boolean isLeftToRight() { + Boolean n = (Boolean)props.get(PROP_LEFT_TO_RIGHT); + if (n == null) return false; + return n.booleanValue(); + } + + public boolean isReadOnce() { + Boolean n = (Boolean)props.get(PROP_READ_ONCE); + if (n == null) return false; + return n.booleanValue(); + } + + public boolean isReadable() { + Boolean n = (Boolean)props.get(PROP_READBLE); + if (n == null) return false; + return n.booleanValue(); + } + + public boolean isVolatile() { + Boolean n = (Boolean)props.get(PROP_VOLATILE); + if (n == null) return false; + return n.booleanValue(); + } + + public boolean isWriteOnce() { + Boolean n = (Boolean)props.get(PROP_WRITE_ONCE); + if (n == null) return false; + return n.booleanValue(); + } + + public boolean isWriteable() { + Boolean n = (Boolean)props.get(PROP_WRITEABLE); + if (n == null) return false; + return n.booleanValue(); + } + + @SuppressWarnings("unchecked") + public Collection canSearch() { + return (Collection)props.get(PROP_CAN_SEARCH); + } + + public Number getMemoryAddress() { + return (Number)props.get(PROP_MEMORY_ADDRESS); + } + + public String getMemoryContext() { + return (String)props.get(PROP_MEMORY_CONTEXT); + } + + public String getProcessID() { + return (String)props.get(PROP_PROCESS_ID); + } + + public String getRole() { + // TODO Auto-generated method stub + return null; + } + + public IToken get(final DoneGet done) { + return new Command(channel, RegistersProxy.this, "get", + new Object[]{ getID() }) { + @Override + public void done(Exception error, Object[] args) { + byte[] val = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + val = JSON.toByteArray(args[1]); + } + done.doneGet(token, error, val); + } + }.token; + } + + public IToken set(byte[] value, final DoneSet done) { + return new Command(channel, RegistersProxy.this, "set", + new Object[]{ getID(), new JSON.Binary(value, 0, value.length) }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneSet(token, error); + } + }.token; + } + + public IToken search(Map filter, final DoneSearch done) { + return new Command(channel, RegistersProxy.this, "search", + new Object[]{ getID(), filter }) { + @Override + public void done(Exception error, Object[] args) { + String[][] paths = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + paths = toPathArray(args[1]); + } + done.doneSearch(token, error, paths); + } + }.token; + } + + public String toString() { + return "[Registers Context " + props.toString() + "]"; + } + } + + public RegistersProxy(IChannel channel) { + this.channel = channel; + } + + public String getName() { + return NAME; + } + + public IToken getChildren(String parent_context_id, final DoneGetChildren done) { + return new Command(channel, this, "getChildren", new Object[]{ parent_context_id }) { + @Override + public void done(Exception error, Object[] args) { + String[] arr = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + arr = toStringArray(args[1]); + } + done.doneGetChildren(token, error, arr); + } + }.token; + } + + public IToken getContext(String id, final DoneGetContext done) { + return new Command(channel, this, "getContext", new Object[]{ id }) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + Context ctx = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + if (args[1] != null) ctx = new Context((Map)args[1]); + } + done.doneGetContext(token, error, ctx); + } + }.token; + } + + public IToken getm(Location[] locs, final DoneGet done) { + return new Command(channel, this, "getm", new Object[]{ locs }) { + @Override + public void done(Exception error, Object[] args) { + byte[] val = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + val = JSON.toByteArray(args[1]); + } + done.doneGet(token, error, val); + } + }.token; + } + + public IToken setm(Location[] locs, byte[] value, final DoneSet done) { + return new Command(channel, this, "setm", + new Object[]{ locs, new JSON.Binary(value, 0, value.length) }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneSet(token, error); + } + }.token; + } + + public void addListener(final RegistersListener listener) { + IChannel.IEventListener l = new IChannel.IEventListener() { + + public void event(String name, byte[] data) { + try { + Object[] args = JSON.parseSequence(data); + if (name.equals("contextChanged")) { + listener.contextChanged(); + } + else if (name.equals("registerChanged")) { + assert args.length == 1; + listener.registerChanged((String)args[0]); + } + else { + throw new IOException("Registers service: unknown event: " + name); + } + } + catch (Throwable x) { + channel.terminate(x); + } + } + }; + channel.addEventListener(this, l); + listeners.put(listener, l); + } + + public void removeListener(RegistersListener listener) { + IChannel.IEventListener l = listeners.remove(listener); + if (l != null) channel.removeEventListener(this, l); + } + + @SuppressWarnings("unchecked") + private String[] toStringArray(Object o) { + if (o == null) return null; + Collection c = (Collection)o; + return (String[])c.toArray(new String[c.size()]); + } + + @SuppressWarnings("unchecked") + private int[] toIntArray(Object o) { + if (o == null) return null; + Collection c = (Collection)o; + int i = 0; + int[] arr = new int[c.size()]; + for (Number n : c) arr[i++] = n.intValue(); + return arr; + } + + @SuppressWarnings("unchecked") + private String[][] toPathArray(Object o) { + if (o == null) return null; + Collection> c = (Collection>)o; + int i = 0; + String[][] r = new String[c.size()][]; + for (Collection p : c) { + r[i++] = (String[])p.toArray(new String[p.size()]); + } + return r; + } + + private static class NamedValueInfo implements NamedValue { + + private final String desc; + private final String name; + private final byte[] value; + + NamedValueInfo(Map m) { + desc = (String)m.get("Description"); + name = (String)m.get("Name"); + value = JSON.toByteArray(m.get("Value")); + } + + public String getDescription() { + return desc; + } + + public String getName() { + return name; + } + + public byte[] getValue() { + return value; + } + } + + @SuppressWarnings("unchecked") + private NamedValue[] toValuesArray(Object o) { + Collection> c = (Collection>)o; + if (c == null) return null; + int i = 0; + NamedValue[] arr = new NamedValue[c.size()]; + for (final Map m : c) { + arr[i++] = new NamedValueInfo(m); + } + return arr; + } + + static { + JSON.addObjectWriter(Location.class, new JSON.ObjectWriter() { + public void write(Object o) throws IOException { + Location l = (Location)o; + JSON.write('['); + JSON.writeObject(l.id); + JSON.write(','); + JSON.writeUInt(l.offs); + JSON.write(','); + JSON.writeUInt(l.size); + JSON.write(']'); + } + }); + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/RunControlProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/RunControlProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,263 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.remote; + +import java.io.IOException; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.tm.tcf.core.Command; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.services.IRunControl; + + +public class RunControlProxy implements IRunControl { + + private final IChannel channel; + private final Map listeners = + new HashMap(); + + private class RunContext implements IRunControl.RunControlContext { + + private final Map props; + + RunContext(Map props) { + this.props = props; + } + + public Map getProperties() { + return props; + } + + public String getID() { + return (String)props.get(PROP_ID); + } + + public String getParentID() { + return (String)props.get(PROP_PARENT_ID); + } + + public boolean isContainer() { + Boolean b = (Boolean)props.get(PROP_IS_CONTAINER); + return b != null && b.booleanValue(); + } + + public boolean hasState() { + Boolean b = (Boolean)props.get(PROP_HAS_STATE); + return b != null && b.booleanValue(); + } + + public boolean canResume(int mode) { + if (props.containsKey(PROP_CAN_RESUME)) { + int b = ((Number)props.get(PROP_CAN_RESUME)).intValue(); + return (b & (1 << mode)) != 0; + } + return false; + } + + public boolean canCount(int mode) { + if (props.containsKey(PROP_CAN_COUNT)) { + int b = ((Number)props.get(PROP_CAN_COUNT)).intValue(); + return (b & (1 << mode)) != 0; + } + return false; + } + + public boolean canSuspend() { + Boolean b = (Boolean)props.get(PROP_CAN_SUSPEND); + return b != null && b.booleanValue(); + } + + public boolean canTerminate() { + Boolean b = (Boolean)props.get(PROP_CAN_TERMINATE); + return b != null && b.booleanValue(); + } + + public IToken getState(final DoneGetState done) { + return new Command(channel, RunControlProxy.this, "getState", new Object[]{ getID() }) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + boolean susp = false; + String pc = null; + String reason = null; + Map map = null; + if (error == null) { + assert args.length == 5; + error = toError(args[0]); + susp = ((Boolean)args[1]).booleanValue(); + if (args[2] != null) pc = ((Number)args[2]).toString(); + reason = (String)args[3]; + map = (Map)args[4]; + } + done.doneGetState(token, error, susp, pc, reason, map); + } + }.token; + } + + public IToken resume(int mode, int count, DoneCommand done) { + return command("resume", new Object[]{ getID(), mode, count }, done); + } + + public IToken resume(int mode, int count, Map params, DoneCommand done) { + if (params == null) return resume(mode, count, done); + return command("resume", new Object[]{ getID(), mode, count, params }, done); + } + + public IToken suspend(DoneCommand done) { + return command("suspend", new Object[]{ getID() }, done); + } + + public IToken terminate(DoneCommand done) { + return command("terminate", new Object[]{ getID() }, done); + } + + private IToken command(String cmd, Object[] args, final DoneCommand done) { + return new Command(channel, RunControlProxy.this, cmd, args) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneCommand(token, error); + } + }.token; + } + + public String toString() { + return "[Run Control Context " + props.toString() + "]"; + } + } + + public RunControlProxy(IChannel channel) { + this.channel = channel; + } + + public String getName() { + return NAME; + } + + public void addListener(final RunControlListener listener) { + IChannel.IEventListener l = new IChannel.IEventListener() { + + @SuppressWarnings("unchecked") + public void event(String name, byte[] data) { + try { + Object[] args = JSON.parseSequence(data); + if (name.equals("contextSuspended")) { + assert args.length == 4; + listener.contextSuspended( + (String)args[0], + args[1] == null ? null : ((Number)args[1]).toString(), + (String)args[2], (Map)args[3]); + } + else if (name.equals("contextResumed")) { + assert args.length == 1; + listener.contextResumed((String)args[0]); + } + else if (name.equals("contextAdded")) { + assert args.length == 1; + listener.contextAdded(toContextArray(args[0])); + } + else if (name.equals("contextChanged")) { + assert args.length == 1; + listener.contextChanged(toContextArray(args[0])); + } + else if (name.equals("contextRemoved")) { + assert args.length == 1; + listener.contextRemoved(toStringArray(args[0])); + } + else if (name.equals("contextException")) { + assert args.length == 2; + listener.contextException((String)args[0], (String)args[1]); + } + else if (name.equals("containerSuspended")) { + assert args.length == 5; + listener.containerSuspended( + (String)args[0], + args[1] == null ? null : ((Number)args[1]).toString(), + (String)args[2], (Map)args[3], + toStringArray(args[4])); + } + else if (name.equals("containerResumed")) { + assert args.length == 1; + listener.containerResumed(toStringArray(args[0])); + } + else { + throw new IOException("RunControl service: unknown event: " + name); + } + } + catch (Throwable x) { + channel.terminate(x); + } + } + }; + channel.addEventListener(this, l); + listeners.put(listener, l); + } + + public void removeListener(RunControlListener listener) { + IChannel.IEventListener l = listeners.remove(listener); + if (l != null) channel.removeEventListener(this, l); + } + + public IToken getContext(String context_id, final DoneGetContext done) { + return new Command(channel, this, "getContext", new Object[]{ context_id }) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + RunControlContext ctx = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + if (args[1] != null) ctx = new RunContext((Map)args[1]); + } + done.doneGetContext(token, error, ctx); + } + }.token; + } + + public IToken getChildren(String parent_context_id, final DoneGetChildren done) { + return new Command(channel, this, "getChildren", new Object[]{ parent_context_id }) { + @Override + public void done(Exception error, Object[] args) { + String[] arr = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + arr = toStringArray(args[1]); + } + done.doneGetChildren(token, error, arr); + } + }.token; + } + + @SuppressWarnings("unchecked") + private RunControlContext[] toContextArray(Object o) { + if (o == null) return null; + Collection> c = (Collection>)o; + int n = 0; + RunControlContext[] ctx = new RunControlContext[c.size()]; + for (Map m : c) ctx[n++] = new RunContext(m); + return ctx; + } + + @SuppressWarnings("unchecked") + private String[] toStringArray(Object o) { + if (o == null) return null; + Collection c = (Collection)o; + return (String[])c.toArray(new String[c.size()]); + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/StackTraceProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/StackTraceProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,129 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.remote; + +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.tm.tcf.core.Command; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.services.IStackTrace; + + +public class StackTraceProxy implements IStackTrace { + + private final IChannel channel; + + private class Context implements StackTraceContext { + + private final Map props; + + Context(Map props) { + if (props == null) props = new HashMap(); + this.props = props; + } + + public Number getArgumentsAddress() { + return (Number)props.get(PROP_ARGUMENTS_ADDRESS); + } + + public int getArgumentsCount() { + Number n = (Number)props.get(PROP_ARGUMENTS_COUNT); + if (n == null) return 0; + return n.intValue(); + } + + public Number getFrameAddress() { + return (Number)props.get(PROP_FRAME_ADDRESS); + } + + public String getID() { + return (String)props.get(PROP_ID); + } + + public String getName() { + return (String)props.get(PROP_NAME); + } + + public String getParentID() { + return (String)props.get(PROP_PARENT_ID); + } + + public Number getReturnAddress() { + return (Number)props.get(PROP_RETURN_ADDRESS); + } + + public Number getInstructionAddress() { + return (Number)props.get(PROP_INSTRUCTION_ADDRESS); + } + + public Map getProperties() { + return props; + } + } + + public StackTraceProxy(IChannel channel) { + this.channel = channel; + } + + public IToken getChildren(String parent_context_id, final DoneGetChildren done) { + return new Command(channel, this, "getChildren", new Object[]{ parent_context_id }) { + @Override + public void done(Exception error, Object[] args) { + String[] arr = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + arr = toStringArray(args[1]); + } + done.doneGetChildren(token, error, arr); + } + }.token; + } + + public IToken getContext(String[] id, final DoneGetContext done) { + return new Command(channel, this, "getContext", new Object[]{ id }) { + @Override + public void done(Exception error, Object[] args) { + StackTraceContext[] arr = null; + if (error == null) { + assert args.length == 2; + error = toError(args[1]); + arr = toContextArray(args[0]); + } + done.doneGetContext(token, error, arr); + } + }.token; + } + + public String getName() { + return NAME; + } + + @SuppressWarnings("unchecked") + private StackTraceContext[] toContextArray(Object o) { + if (o == null) return null; + Collection> c = (Collection>)o; + int n = 0; + StackTraceContext[] ctx = new StackTraceContext[c.size()]; + for (Map m : c) ctx[n++] = new Context(m); + return ctx; + } + + @SuppressWarnings("unchecked") + private String[] toStringArray(Object o) { + if (o == null) return null; + Collection c = (Collection)o; + return (String[])c.toArray(new String[c.size()]); + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/StreamsProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/StreamsProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,168 @@ +/******************************************************************************* + * Copyright (c) 2009 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.remote; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.tm.tcf.core.Command; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.services.IStreams; + +public class StreamsProxy implements IStreams { + + private final IChannel channel; + private final Map listeners = + new HashMap(); + + public StreamsProxy(IChannel channel) { + this.channel = channel; + } + + public IToken connect(String stream_id, final DoneConnect done) { + return new Command(channel, this, "connect", new Object[]{ stream_id }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneConnect(token, error); + } + }.token; + } + + public IToken disconnect(String stream_id, final DoneDisconnect done) { + return new Command(channel, this, "disconnect", new Object[]{ stream_id }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneDisconnect(token, error); + } + }.token; + } + + public IToken eos(String stream_id, final DoneEOS done) { + return new Command(channel, this, "eos", new Object[]{ stream_id }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneEOS(token, error); + } + }.token; + } + + public IToken read(String stream_id, int size, final DoneRead done) { + return new Command(channel, this, "read", new Object[]{ stream_id, size }) { + @Override + public void done(Exception error, Object[] args) { + int lost_size = 0; + byte data[] = null; + boolean eos = false; + if (error == null) { + assert args.length == 4; + data = JSON.toByteArray(args[0]); + error = toError(args[1]); + lost_size = ((Number)args[2]).intValue(); + eos = ((Boolean)args[3]).booleanValue(); + } + done.doneRead(token, error, lost_size, data, eos); + } + }.token; + } + + public IToken subscribe(String stream_type, final StreamsListener listener, final DoneSubscribe done) { + return new Command(channel, this, "subscribe", new Object[]{ stream_type }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + if (error == null) { + IChannel.IEventListener l = new IChannel.IEventListener() { + + public void event(String name, byte[] data) { + try { + Object[] args = JSON.parseSequence(data); + if (name.equals("created")) { + if (args.length == 3) { + listener.created((String)args[0], (String)args[1], (String)args[2]); + } + else { + assert args.length == 2; + listener.created((String)args[0], (String)args[1], null); + } + } + else if (name.equals("disposed")) { + assert args.length == 2; + listener.disposed((String)args[0], (String)args[1]); + } + else { + throw new IOException("Streams service: unknown event: " + name); + } + } + catch (Throwable x) { + channel.terminate(x); + } + } + }; + listeners.put(listener, l); + channel.addEventListener(StreamsProxy.this, l); + } + done.doneSubscribe(token, error); + } + }.token; + } + + public IToken unsubscribe(String stream_type, final StreamsListener listener, final DoneUnsubscribe done) { + return new Command(channel, this, "unsubscribe", new Object[]{ stream_type }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + if (error == null) { + IChannel.IEventListener l = listeners.remove(listener); + if (l != null) channel.removeEventListener(StreamsProxy.this, l); + } + done.doneUnsubscribe(token, error); + } + }.token; + } + + public IToken write(String stream_id, byte[] buf, int offset, int size, final DoneWrite done) { + return new Command(channel, this, "write", new Object[]{ stream_id, size, new JSON.Binary(buf, offset, size) }) { + @Override + public void done(Exception error, Object[] args) { + if (error == null) { + assert args.length == 1; + error = toError(args[0]); + } + done.doneWrite(token, error); + } + }.token; + } + + public String getName() { + return NAME; + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/SymbolsProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/SymbolsProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,156 @@ +package org.eclipse.tm.internal.tcf.services.remote; + +import java.util.Collection; +import java.util.Map; + +import org.eclipse.tm.tcf.core.Command; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.services.ISymbols; + +public class SymbolsProxy implements ISymbols { + + private final IChannel channel; + + private class Context implements Symbol { + + private final byte[] value; + private final Map props; + + Context(Map props) { + this.props = props; + value = JSON.toByteArray(props.get(PROP_VALUE)); + } + + public Number getAddress() { + return (Number)props.get(PROP_ADDRESS); + } + + public String getBaseTypeID() { + return (String)props.get(PROP_BASE_TYPE_ID); + } + + public String getExeContextID() { + return (String)props.get(PROP_EXE_ID); + } + + public String getID() { + return (String)props.get(PROP_ID); + } + + public String getIndexTypeID() { + return (String)props.get(PROP_INDEX_TYPE_ID); + } + + public int getLength() { + Number n = (Number)props.get(PROP_LENGTH); + if (n == null) return 0; + return n.intValue(); + } + + public String getName() { + return (String)props.get(PROP_NAME); + } + + public int getOffset() { + Number n = (Number)props.get(PROP_OFFSET); + if (n == null) return 0; + return n.intValue(); + } + + public Map getProperties() { + return props; + } + + public int getSize() { + Number n = (Number)props.get(PROP_SIZE); + if (n == null) return 0; + return n.intValue(); + } + + public SymbolClass getSymbolClass() { + Number n = (Number)props.get(PROP_SYMBOL_CLASS); + if (n != null) { + switch (n.intValue()) { + case 1: return SymbolClass.value; + case 2: return SymbolClass.reference; + case 3: return SymbolClass.function; + case 4: return SymbolClass.type; + } + } + return SymbolClass.unknown; + } + + public TypeClass getTypeClass() { + Number n = (Number)props.get(PROP_TYPE_CLASS); + if (n != null) { + switch (n.intValue()) { + case 1: return TypeClass.cardinal; + case 2: return TypeClass.integer; + case 3: return TypeClass.real; + case 4: return TypeClass.pointer; + case 5: return TypeClass.array; + case 6: return TypeClass.composite; + case 7: return TypeClass.enumeration; + case 8: return TypeClass.function; + } + } + return TypeClass.unknown; + } + + public String getTypeID() { + return (String)props.get(PROP_TYPE_ID); + } + + public byte[] getValue() { + return value; + } + } + + public SymbolsProxy(IChannel channel) { + this.channel = channel; + } + + public String getName() { + return NAME; + } + + public IToken getContext(String id, final DoneGetContext done) { + return new Command(channel, this, "getContext", new Object[]{ id }) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + Context ctx = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + if (args[1] != null) ctx = new Context((Map)args[1]); + } + done.doneGetContext(token, error, ctx); + } + }.token; + } + + public IToken getChildren(String parent_context_id, final DoneGetChildren done) { + return new Command(channel, this, "getChildren", new Object[]{ parent_context_id }) { + @Override + public void done(Exception error, Object[] args) { + String[] lst = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + lst = toStringArray(args[1]); + } + done.doneGetChildren(token, error, lst); + } + }.token; + } + + @SuppressWarnings("unchecked") + private String[] toStringArray(Object o) { + if (o == null) return null; + Collection c = (Collection)o; + return (String[])c.toArray(new String[c.size()]); + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/SysMonitorProxy.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/internal/tcf/services/remote/SysMonitorProxy.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,200 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.internal.tcf.services.remote; + +import java.util.Collection; +import java.util.Map; + +import org.eclipse.tm.tcf.core.Command; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.services.ISysMonitor; + + +public class SysMonitorProxy implements ISysMonitor { + + private final IChannel channel; + + private class SysMonitorContext implements ISysMonitor.SysMonitorContext { + + private final Map props; + + SysMonitorContext(Map props) { + this.props = props; + } + + public String getID() { + return (String)props.get(PROP_ID); + } + + public String getCurrentWorkingDirectory() { + return (String)props.get(PROP_CWD); + } + + public String getFile() { + return (String)props.get(PROP_FILE); + } + + public String getParentID() { + return (String)props.get(PROP_PARENTID); + } + + public String getRoot() { + return (String)props.get(PROP_ROOT); + } + + public String getGroupName() { + return (String)props.get(PROP_GROUPNAME); + } + + public long getPGRP() { + if (!props.containsKey(PROP_PGRP)) return -1; + return ((Number)props.get(PROP_PGRP)).longValue(); + } + + public long getPID() { + if (!props.containsKey(PROP_PID)) return -1; + return ((Number)props.get(PROP_PID)).longValue(); + } + + public long getPPID() { + if (!props.containsKey(PROP_PPID)) return -1; + return ((Number)props.get(PROP_PPID)).longValue(); + } + + public long getRSS() { + if (!props.containsKey(PROP_RSS)) return -1; + return ((Number)props.get(PROP_RSS)).longValue(); + } + + public String getState() { + return (String)props.get(PROP_STATE); + } + + public long getTGID() { + if (!props.containsKey(PROP_TGID)) return -1; + return ((Number)props.get(PROP_TGID)).longValue(); + } + + public long getTracerPID() { + if (!props.containsKey(PROP_TRACERPID)) return -1; + return ((Number)props.get(PROP_TRACERPID)).longValue(); + } + + public long getUGID() { + if (!props.containsKey(PROP_UGID)) return -1; + return ((Number)props.get(PROP_UGID)).longValue(); + } + + public long getUID() { + if (!props.containsKey(PROP_UID)) return -1; + return ((Number)props.get(PROP_UID)).longValue(); + } + + public String getUserName() { + return (String)props.get(PROP_USERNAME); + } + + public long getVSize() { + if (!props.containsKey(PROP_VSIZE)) return -1; + return ((Number)props.get(PROP_VSIZE)).longValue(); + } + + public long getPSize() { + if (!props.containsKey(PROP_PSIZE)) return -1; + return ((Number)props.get(PROP_PSIZE)).longValue(); + } + + public Map getProperties() { + return props; + } + + public String toString() { + return "[Sys Monitor Context " + props.toString() + "]"; + } + } + + public SysMonitorProxy(IChannel channel) { + this.channel = channel; + } + + public String getName() { + return NAME; + } + + public IToken getChildren(String parent_context_id, final DoneGetChildren done) { + return new Command(channel, this, "getChildren", new Object[]{ parent_context_id }) { + @Override + public void done(Exception error, Object[] args) { + String[] arr = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + arr = toStringArray(args[1]); + } + done.doneGetChildren(token, error, arr); + } + }.token; + } + + public IToken getContext(String id, final DoneGetContext done) { + return new Command(channel, this, "getContext", new Object[]{ id }) { + @SuppressWarnings("unchecked") + @Override + public void done(Exception error, Object[] args) { + SysMonitorContext ctx = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + if (args[1] != null) ctx = new SysMonitorContext((Map)args[1]); + } + done.doneGetContext(token, error, ctx); + } + }.token; + } + + public IToken getCommandLine(String id, final DoneGetCommandLine done) { + return new Command(channel, this, "getCommandLine", new Object[]{ id }) { + @Override + public void done(Exception error, Object[] args) { + String[] arr = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + arr = toStringArray(args[1]); + } + done.doneGetCommandLine(token, error, arr); + } + }.token; + } + + public IToken getEnvironment(String id, final DoneGetEnvironment done) { + return new Command(channel, this, "getEnvironment", new Object[]{ id }) { + @Override + public void done(Exception error, Object[] args) { + String[] arr = null; + if (error == null) { + assert args.length == 2; + error = toError(args[0]); + arr = toStringArray(args[1]); + } + done.doneGetEnvironment(token, error, arr); + } + }.token; + } + + @SuppressWarnings("unchecked") + private static String[] toStringArray(Object o) { + if (o == null) return null; + Collection c = (Collection)o; + return (String[])c.toArray(new String[c.size()]); + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/tcf/core/AbstractChannel.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/tcf/core/AbstractChannel.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,973 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.tcf.core; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.Map; + +import org.eclipse.tm.internal.tcf.core.ServiceManager; +import org.eclipse.tm.internal.tcf.core.Token; +import org.eclipse.tm.internal.tcf.core.TransportManager; +import org.eclipse.tm.internal.tcf.services.local.LocatorService; +import org.eclipse.tm.internal.tcf.services.remote.GenericProxy; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IErrorReport; +import org.eclipse.tm.tcf.protocol.IPeer; +import org.eclipse.tm.tcf.protocol.IService; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.protocol.Protocol; +import org.eclipse.tm.tcf.services.ILocator; + +/** + * Abstract implementation of IChannel interface. + * + * AbstractChannel implements communication link connecting two end points (peers). + * The channel asynchronously transmits messages: commands, results and events. + * + * Clients can subclass AbstractChannel to support particular transport (wire) protocol. + * Also, see StreamChannel for stream oriented transport protocols. + */ +public abstract class AbstractChannel implements IChannel { + + public interface TraceListener { + + public void onMessageReceived(char type, String token, + String service, String name, byte[] data); + + public void onMessageSent(char type, String token, + String service, String name, byte[] data); + + public void onChannelClosed(Throwable error); + } + + public interface Proxy { + + public void onCommand(IToken token, String service, String name, byte[] data); + + public void onEvent(String service, String name, byte[] data); + + public void onChannelClosed(Throwable error); + } + + private static class Message { + final char type; + Token token; + String service; + String name; + byte[] data; + + boolean is_sent; + boolean is_canceled; + + Collection trace; + + Message(char type) { + this.type = type; + } + + @Override + public String toString() { + try { + StringBuffer bf = new StringBuffer(); + bf.append('[');; + bf.append(type); + if (token != null) { + bf.append(' '); + bf.append(token.getID()); + } + if (service != null) { + bf.append(' '); + bf.append(service); + } + if (name != null) { + bf.append(' '); + bf.append(name); + } + if (data != null) { + int i = 0; + while (i < data.length) { + int j = i; + while (j < data.length && data[j] != 0) j++; + bf.append(' '); + bf.append(new String(data, i, j - i, "UTF8")); + if (j < data.length && data[j] == 0) j++; + i = j; + } + } + bf.append(']'); + return bf.toString(); + } + catch (Exception x) { + return x.toString(); + } + } + } + + private static IChannelListener[] listeners_array = new IChannelListener[4]; + + private final LinkedList redirect_queue = new LinkedList(); + private final Map,IService> local_service_by_class = new HashMap,IService>(); + private final Map,IService> remote_service_by_class = new HashMap,IService>(); + private final Map local_service_by_name = new HashMap(); + private final Map remote_service_by_name = new HashMap(); + private final LinkedList out_queue = new LinkedList(); + private final Collection channel_listeners = new ArrayList(); + private final Map event_listeners = new HashMap(); + private final Map command_servers = new HashMap(); + private final Map out_tokens = new HashMap(); + private final Thread inp_thread; + private final Thread out_thread; + private boolean notifying_channel_opened; + private boolean registered_with_trasport; + private boolean shutdown; + private int state = STATE_OPENNING; + private IToken redirect_command; + private final IPeer local_peer; + private IPeer remote_peer; + private Proxy proxy; + private boolean zero_copy; + + private static final int pending_command_limit = 32; + private int local_congestion_level = -100; + private int remote_congestion_level = -100; + private long local_congestion_time; + private int local_congestion_cnt; + private Collection trace_listeners; + + public static final int + EOS = -1, // End Of Stream + EOM = -2; // End Of Message + + protected AbstractChannel(IPeer remote_peer) { + this(LocatorService.getLocalPeer(), remote_peer); + } + + protected AbstractChannel(IPeer local_peer, IPeer remote_peer) { + assert Protocol.isDispatchThread(); + this.remote_peer = remote_peer; + this.local_peer = local_peer; + + inp_thread = new Thread() { + + final byte[] empty_byte_array = new byte[0]; + byte[] buf = new byte[1024]; + byte[] eos; + + private void error() throws IOException { + throw new IOException("Protocol syntax error"); + } + + private byte[] readBytes(int end) throws IOException { + int len = 0; + for (;;) { + int n = read(); + if (n <= 0) { + if (n == end) break; + if (n == EOM) throw new IOException("Unexpected end of message"); + if (n < 0) throw new IOException("Communication channel is closed by remote peer"); + } + if (len >= buf.length) { + byte[] tmp = new byte[buf.length * 2]; + System.arraycopy(buf, 0, tmp, 0, len); + buf = tmp; + } + buf[len++] = (byte)n; + } + if (len == 0) return empty_byte_array; + byte[] res = new byte[len]; + System.arraycopy(buf, 0, res, 0, len); + return res; + } + + private String readString() throws IOException { + int len = 0; + for (;;) { + int n = read(); + if (n <= 0) { + if (n == 0) break; + if (n == EOM) throw new IOException("Unexpected end of message"); + if (n < 0) throw new IOException("Communication channel is closed by remote peer"); + } + if (len >= buf.length) { + byte[] tmp = new byte[buf.length * 2]; + System.arraycopy(buf, 0, tmp, 0, len); + buf = tmp; + } + buf[len++] = (byte)n; + } + return new String(buf, 0, len, "UTF8"); + } + + @Override + public void run() { + try { + while (true) { + int n = read(); + if (n == EOM) continue; + if (n == EOS) { + eos = readBytes(EOM); + break; + } + final Message msg = new Message((char)n); + if (read() != 0) error(); + switch (msg.type) { + case 'C': + msg.token = new Token(readBytes(0)); + msg.service = readString(); + msg.name = readString(); + msg.data = readBytes(EOM); + break; + case 'P': + case 'R': + case 'N': + msg.token = new Token(readBytes(0)); + msg.data = readBytes(EOM); + break; + case 'E': + msg.service = readString(); + msg.name = readString(); + msg.data = readBytes(EOM); + break; + case 'F': + msg.data = readBytes(EOM); + break; + default: + error(); + } + Protocol.invokeLater(new Runnable() { + public void run() { + handleInput(msg); + } + }); + int delay = local_congestion_level; + if (delay > 0) sleep(delay); + } + Protocol.invokeLater(new Runnable() { + public void run() { + if (out_tokens.isEmpty()) { + close(); + } + else { + IOException x = new IOException("Connection reset by peer"); + try { + Object[] args = JSON.parseSequence(eos); + if (args.length > 0 && args[0] != null) { + x = new IOException(Command.toErrorString(args[0])); + } + } + catch (IOException e) { + x = e; + } + terminate(x); + } + } + }); + } + catch (final Throwable x) { + Protocol.invokeLater(new Runnable() { + public void run() { + terminate(x); + } + }); + } + } + }; + + out_thread = new Thread() { + + @Override + public void run() { + try { + while (true) { + Message msg = null; + boolean last = false; + synchronized (out_queue) { + while (out_queue.isEmpty()) out_queue.wait(); + msg = out_queue.removeFirst(); + if (msg == null) break; + last = out_queue.isEmpty(); + if (msg.is_canceled) { + if (last) flush(); + continue; + } + msg.is_sent = true; + } + if (msg.trace != null) { + final Message m = msg; + Protocol.invokeLater(new Runnable() { + public void run() { + for (TraceListener l : m.trace) { + try { + l.onMessageSent(m.type, m.token == null ? null : m.token.getID(), + m.service, m.name, m.data); + } + catch (Throwable x) { + Protocol.log("Exception in channel listener", x); + } + } + } + }); + } + write(msg.type); + write(0); + if (msg.token != null) { + write(msg.token.getBytes()); + write(0); + } + if (msg.service != null) { + write(msg.service.getBytes("UTF8")); + write(0); + } + if (msg.name != null) { + write(msg.name.getBytes("UTF8")); + write(0); + } + if (msg.data != null) { + write(msg.data); + } + write(EOM); + int delay = 0; + int level = remote_congestion_level; + if (level > 0) delay = level * 10; + if (last || delay > 0) flush(); + if (delay > 0) sleep(delay); + else yield(); + } + write(EOS); + write(EOM); + flush(); + } + catch (final Throwable x) { + Protocol.invokeLater(new Runnable() { + public void run() { + terminate(x); + } + }); + } + } + }; + inp_thread.setName("TCF Channel Receiver"); + out_thread.setName("TCF Channel Transmitter"); + } + + protected void start() { + assert Protocol.isDispatchThread(); + Protocol.invokeLater(new Runnable() { + public void run() { + try { + if (proxy != null) return; + if (state == STATE_CLOSED) return; + ServiceManager.onChannelCreated(AbstractChannel.this, local_service_by_name); + makeServiceByClassMap(local_service_by_name, local_service_by_class); + Object[] args = new Object[]{ local_service_by_name.keySet() }; + sendEvent(Protocol.getLocator(), "Hello", JSON.toJSONSequence(args)); + } + catch (IOException x) { + terminate(x); + } + } + }); + inp_thread.start(); + out_thread.start(); + } + + /** + * Redirect this channel to given peer using this channel remote peer locator service as a proxy. + * @param peer_id - peer that will become new remote communication endpoint of this channel + */ + public void redirect(final String peer_id) { + assert Protocol.isDispatchThread(); + if (state == STATE_OPENNING) { + redirect_queue.add(peer_id); + } + else { + assert state == STATE_OPEN; + assert redirect_command == null; + try { + final ILocator l = (ILocator)remote_service_by_class.get(ILocator.class); + if (l == null) throw new IOException("Cannot redirect channel: peer " + + remote_peer.getID() + " has no locator service"); + final IPeer peer = l.getPeers().get(peer_id); + if (peer == null) { + // Peer not found, must wait for a while until peer is discovered or time out + final boolean[] found = new boolean[1]; + Protocol.invokeLater(ILocator.DATA_RETENTION_PERIOD / 3, new Runnable() { + public void run() { + if (found[0]) return; + terminate(new Exception("Peer " + peer_id + " not found")); + } + }); + l.addListener(new ILocator.LocatorListener() { + public void peerAdded(IPeer peer) { + if (peer.getID().equals(peer_id)) { + found[0] = true; + state = STATE_OPEN; + l.removeListener(this); + redirect(peer_id); + } + } + public void peerChanged(IPeer peer) { + } + + public void peerHeartBeat(String id) { + } + + public void peerRemoved(String id) { + } + }); + } + else { + redirect_command = l.redirect(peer_id, new ILocator.DoneRedirect() { + public void doneRedirect(IToken token, Exception x) { + assert redirect_command == token; + redirect_command = null; + if (state != STATE_OPENNING) return; + if (x != null) terminate(x); + remote_peer = peer; + remote_service_by_class.clear(); + remote_service_by_name.clear(); + event_listeners.clear(); + } + }); + } + state = STATE_OPENNING; + } + catch (Throwable x) { + terminate(x); + } + } + } + + private void makeServiceByClassMap(Map by_name, Map,IService> by_class) { + for (IService service : by_name.values()) { + for (Class fs : service.getClass().getInterfaces()) { + if (fs.equals(IService.class)) continue; + if (!IService.class.isAssignableFrom(fs)) continue; + by_class.put(fs, service); + } + } + } + + public final int getState() { + return state; + } + + public void addChannelListener(IChannelListener listener) { + assert Protocol.isDispatchThread(); + assert listener != null; + channel_listeners.add(listener); + } + + public void removeChannelListener(IChannelListener listener) { + assert Protocol.isDispatchThread(); + channel_listeners.remove(listener); + } + + public void addTraceListener(TraceListener listener) { + if (trace_listeners == null) { + trace_listeners = new ArrayList(); + } + else { + trace_listeners = new ArrayList(trace_listeners); + } + trace_listeners.add(listener); + } + + public void removeTraceListener(TraceListener listener) { + trace_listeners = new ArrayList(trace_listeners); + trace_listeners.remove(listener); + if (trace_listeners.isEmpty()) trace_listeners = null; + } + + public void addEventListener(IService service, IChannel.IEventListener listener) { + assert Protocol.isDispatchThread(); + IChannel.IEventListener[] list = event_listeners.get(service.getName()); + IChannel.IEventListener[] next = new IChannel.IEventListener[list == null ? 1 : list.length + 1]; + if (list != null) System.arraycopy(list, 0, next, 0, list.length); + next[next.length - 1] = listener; + event_listeners.put(service.getName(), next); + } + + public void removeEventListener(IService service, IChannel.IEventListener listener) { + assert Protocol.isDispatchThread(); + IChannel.IEventListener[] list = event_listeners.get(service.getName()); + for (int i = 0; i < list.length; i++) { + if (list[i] == listener) { + if (list.length == 1) { + event_listeners.remove(service.getName()); + } + else { + IChannel.IEventListener[] next = new IChannel.IEventListener[list.length - 1]; + System.arraycopy(list, 0, next, 0, i); + System.arraycopy(list, i + 1, next, i, next.length - i); + event_listeners.put(service.getName(), next); + } + return; + } + } + } + + public void addCommandServer(IService service, IChannel.ICommandServer listener) { + assert Protocol.isDispatchThread(); + if (command_servers.put(service.getName(), listener) != null) { + throw new Error("Only one command server per service is allowed"); + } + } + + public void removeCommandServer(IService service, IChannel.ICommandServer listener) { + assert Protocol.isDispatchThread(); + if (command_servers.remove(service.getName()) != listener) { + throw new Error("Invalid command server"); + } + } + + private void sendEndOfStream() { + if (shutdown) return; + shutdown = true; + synchronized (out_queue) { + out_queue.clear(); + out_queue.add(0, null); + out_queue.notify(); + } + } + + public void close() { + assert Protocol.isDispatchThread(); + try { + sendEndOfStream(); + out_thread.join(10000); + stop(); + inp_thread.join(10000); + terminate(null); + } + catch (Exception x) { + terminate(x); + } + } + + public void terminate(final Throwable error) { + assert Protocol.isDispatchThread(); + sendEndOfStream(); + if (state == STATE_CLOSED) return; + state = STATE_CLOSED; + if (error != null && remote_peer instanceof AbstractPeer) { + ((AbstractPeer)remote_peer).onChannelTerminated(); + } + if (registered_with_trasport) { + registered_with_trasport = false; + TransportManager.channelClosed(this, error); + } + if (proxy != null) { + try { + proxy.onChannelClosed(error); + } + catch (Throwable x) { + Protocol.log("Exception in channel listener", x); + } + } + Protocol.invokeLater(new Runnable() { + public void run() { + if (!out_tokens.isEmpty()) { + Exception x = null; + if (error instanceof Exception) x = (Exception)error; + else if (error != null) x = new Exception(error); + else x = new IOException("Channel is closed"); + for (Message msg : out_tokens.values()) { + try { + String s = msg.toString(); + if (s.length() > 72) s = s.substring(0, 72) + "...]"; + IOException y = new IOException("Command " + s + " aborted"); + y.initCause(x); + msg.token.getListener().terminated(msg.token, y); + } + catch (Throwable e) { + Protocol.log("Exception in command listener", e); + } + } + out_tokens.clear(); + } + if (channel_listeners.isEmpty()) { + Protocol.log("TCF channel terminated", error); + } + else { + listeners_array = channel_listeners.toArray(listeners_array); + for (IChannelListener l : listeners_array) { + if (l == null) break; + try { + l.onChannelClosed(error); + } + catch (Throwable x) { + Protocol.log("Exception in channel listener", x); + } + } + } + if (trace_listeners != null) { + for (TraceListener l : trace_listeners) { + try { + l.onChannelClosed(error); + } + catch (Throwable x) { + Protocol.log("Exception in channel listener", x); + } + } + } + } + }); + } + + public int getCongestion() { + assert Protocol.isDispatchThread(); + int level = out_tokens.size() * 100 / pending_command_limit - 100; + if (remote_congestion_level > level) level = remote_congestion_level; + if (level > 100) level = 100; + return level; + } + + public IPeer getLocalPeer() { + assert Protocol.isDispatchThread(); + return local_peer; + } + + public IPeer getRemotePeer() { + assert Protocol.isDispatchThread(); + return remote_peer; + } + + public Collection getLocalServices() { + assert Protocol.isDispatchThread(); + assert state != STATE_OPENNING; + return local_service_by_name.keySet(); + } + + public Collection getRemoteServices() { + assert Protocol.isDispatchThread(); + assert state != STATE_OPENNING; + return remote_service_by_name.keySet(); + } + + @SuppressWarnings("unchecked") + public V getLocalService(Class cls) { + assert Protocol.isDispatchThread(); + assert state != STATE_OPENNING; + return (V)local_service_by_class.get(cls); + } + + @SuppressWarnings("unchecked") + public V getRemoteService(Class cls) { + assert Protocol.isDispatchThread(); + assert state != STATE_OPENNING; + return (V)remote_service_by_class.get(cls); + } + + public void setServiceProxy(Class service_interface, IService service_proxy) { + if (!notifying_channel_opened) new Error("setServiceProxe() can be called only from channel open call-back"); + if (!(remote_service_by_name.get(service_proxy.getName()) instanceof GenericProxy)) throw new Error("Proxy already set"); + if (remote_service_by_class.get(service_interface) != null) throw new Error("Proxy already set"); + remote_service_by_class.put(service_interface, service_proxy); + remote_service_by_name.put(service_proxy.getName(), service_proxy); + } + + public IService getLocalService(String service_name) { + assert Protocol.isDispatchThread(); + assert state != STATE_OPENNING; + return local_service_by_name.get(service_name); + } + + public IService getRemoteService(String service_name) { + assert Protocol.isDispatchThread(); + assert state != STATE_OPENNING; + return remote_service_by_name.get(service_name); + } + + public void setProxy(Proxy proxy, Collection services) throws IOException { + this.proxy = proxy; + sendEvent(Protocol.getLocator(), "Hello", JSON.toJSONSequence(new Object[]{ services })); + local_service_by_class.clear(); + local_service_by_name.clear(); + } + + private void addToOutQueue(Message msg) { + msg.trace = trace_listeners; + synchronized (out_queue) { + out_queue.add(msg); + out_queue.notify(); + } + } + + public IToken sendCommand(IService service, String name, byte[] args, ICommandListener listener) { + assert Protocol.isDispatchThread(); + if (state == STATE_OPENNING) throw new Error("Channel is waiting for Hello message"); + if (state == STATE_CLOSED) throw new Error("Channel is closed"); + final Message msg = new Message('C'); + msg.service = service.getName(); + msg.name = name; + msg.data = args; + Token token = new Token(listener) { + @Override + public boolean cancel() { + assert Protocol.isDispatchThread(); + if (state != STATE_OPEN) return false; + synchronized (out_queue) { + if (msg.is_sent) return false; + msg.is_canceled = true; + } + out_tokens.remove(msg.token.getID()); + return true; + } + }; + msg.token = token; + out_tokens.put(token.getID(), msg); + addToOutQueue(msg); + return token; + } + + public void sendProgress(IToken token, byte[] results) { + assert Protocol.isDispatchThread(); + if (state != STATE_OPEN) throw new Error("Channel is closed"); + Message msg = new Message('P'); + msg.data = results; + msg.token = (Token)token; + addToOutQueue(msg); + } + + public void sendResult(IToken token, byte[] results) { + assert Protocol.isDispatchThread(); + if (state != STATE_OPEN) throw new Error("Channel is closed"); + Message msg = new Message('R'); + msg.data = results; + msg.token = (Token)token; + addToOutQueue(msg); + } + + public void rejectCommand(IToken token) { + assert Protocol.isDispatchThread(); + if (state != STATE_OPEN) throw new Error("Channel is closed"); + Message msg = new Message('N'); + msg.token = (Token)token; + addToOutQueue(msg); + } + + public void sendEvent(IService service, String name, byte[] args) { + assert Protocol.isDispatchThread(); + if (!(state == STATE_OPEN || state == STATE_OPENNING && service instanceof ILocator)) { + throw new Error("Channel is closed"); + } + Message msg = new Message('E'); + msg.service = service.getName(); + msg.name = name; + msg.data = args; + addToOutQueue(msg); + } + + public boolean isZeroCopySupported() { + return zero_copy; + } + + @SuppressWarnings("unchecked") + private void handleInput(Message msg) { + assert Protocol.isDispatchThread(); + if (state == STATE_CLOSED) return; + if (trace_listeners != null) { + for (TraceListener l : trace_listeners) { + try { + l.onMessageReceived(msg.type, + msg.token != null ? msg.token.getID() : null, + msg.service, msg.name, msg.data); + } + catch (Throwable x) { + Protocol.log("Exception in trace listener", x); + } + } + } + try { + Token token = null; + switch (msg.type) { + case 'P': + case 'R': + case 'N': + String token_id = msg.token.getID(); + Message cmd = msg.type == 'P' ? out_tokens.get(token_id) : out_tokens.remove(token_id); + if (cmd == null) throw new Exception("Invalid token received: " + token_id); + token = cmd.token; + break; + } + switch (msg.type) { + case 'C': + if (state == STATE_OPENNING) { + throw new IOException("Received command " + msg.service + "." + msg.name + " before Hello message"); + } + if (proxy != null) { + proxy.onCommand(msg.token, msg.service, msg.name, msg.data); + } + else { + token = msg.token; + IChannel.ICommandServer cmds = command_servers.get(msg.service); + if (cmds != null) { + cmds.command(token, msg.name, msg.data); + } + else { + rejectCommand(token); + } + } + break; + case 'P': + token.getListener().progress(token, msg.data); + sendCongestionLevel(); + break; + case 'R': + token.getListener().result(token, msg.data); + sendCongestionLevel(); + break; + case 'N': + token.getListener().terminated(token, new ErrorReport( + "Command is not recognized", IErrorReport.TCF_ERROR_INV_COMMAND)); + break; + case 'E': + boolean hello = msg.service.equals(ILocator.NAME) && msg.name.equals("Hello"); + if (hello) { + remote_service_by_name.clear(); + remote_service_by_class.clear(); + ServiceManager.onChannelOpened(this, (Collection)JSON.parseSequence(msg.data)[0], remote_service_by_name); + makeServiceByClassMap(remote_service_by_name, remote_service_by_class); + zero_copy = remote_service_by_name.containsKey("ZeroCopy"); + } + if (proxy != null && state == STATE_OPEN) { + proxy.onEvent(msg.service, msg.name, msg.data); + } + else if (hello) { + assert state == STATE_OPENNING; + state = STATE_OPEN; + assert redirect_command == null; + if (redirect_queue.size() > 0) { + redirect(redirect_queue.removeFirst()); + } + else { + notifying_channel_opened = true; + if (!registered_with_trasport) { + TransportManager.channelOpened(this); + registered_with_trasport = true; + } + listeners_array = channel_listeners.toArray(listeners_array); + for (IChannelListener l : listeners_array) { + if (l == null) break; + try { + l.onChannelOpened(); + } + catch (Throwable x) { + Protocol.log("Exception in channel listener", x); + } + } + notifying_channel_opened = false; + } + } + else { + IChannel.IEventListener[] list = event_listeners.get(msg.service); + if (list != null) { + for (int i = 0; i < list.length; i++) { + list[i].event(msg.name, msg.data); + } + } + sendCongestionLevel(); + } + break; + case 'F': + int len = msg.data.length; + if (len > 0 && msg.data[len - 1] == 0) len--; + remote_congestion_level = Integer.parseInt(new String(msg.data, 0, len, "ASCII")); + break; + default: + assert false; + break; + } + } + catch (Throwable x) { + terminate(x); + } + } + + private void sendCongestionLevel() throws IOException { + if (++local_congestion_cnt < 8) return; + local_congestion_cnt = 0; + if (state != STATE_OPEN) return; + long time = System.currentTimeMillis(); + if (time - local_congestion_time < 500) return; + assert Protocol.isDispatchThread(); + int level = Protocol.getCongestionLevel(); + if (level == local_congestion_level) return; + int i = (level - local_congestion_level) / 8; + if (i != 0) level = local_congestion_level + i; + local_congestion_time = time; + synchronized (out_queue) { + Message msg = out_queue.isEmpty() ? null : out_queue.get(0); + if (msg == null || msg.type != 'F') { + msg = new Message('F'); + out_queue.add(0, msg); + out_queue.notify(); + } + StringBuilder buffer = new StringBuilder(); + buffer.append(local_congestion_level); + buffer.append((char)0); // 0 terminate + msg.data = buffer.toString().getBytes("ASCII"); + msg.trace = trace_listeners; + local_congestion_level = level; + } + } + + /** + * Read one byte from the channel input stream. + * @return next data byte or EOS (-1) if end of stream is reached, + * or EOM (-2) if end of message is reached. + * @throws IOException + */ + protected abstract int read() throws IOException; + + /** + * Write one byte into the channel output stream. + * The method argument can be one of two special values: + * EOS (-1) end of stream marker; + * EOM (-2) end of message marker. + * The stream can put the byte into a buffer instead of transmitting it right away. + * @param n - the data byte. + * @throws IOException + */ + protected abstract void write(int n) throws IOException; + + /** + * Flush the channel output stream. + * All buffered data should be transmitted immediately. + * @throws IOException + */ + protected abstract void flush() throws IOException; + + /** + * Stop (close) channel underlying streams. + * If a thread is blocked by read() or write(), it should be + * resumed (or interrupted). + * @throws IOException + */ + protected abstract void stop() throws IOException; + + /** + * Write array of bytes into the channel output stream. + * The stream can put bytes into a buffer instead of transmitting it right away. + * @param buf + * @throws IOException + */ + protected void write(byte[] buf) throws IOException { + assert Thread.currentThread() == out_thread; + for (int i = 0; i < buf.length; i++) write(buf[i]); + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/tcf/core/AbstractPeer.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/tcf/core/AbstractPeer.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,186 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.tcf.core; + +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; + +import org.eclipse.tm.internal.tcf.core.TransportManager; +import org.eclipse.tm.internal.tcf.services.local.LocatorService; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IPeer; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.protocol.Protocol; +import org.eclipse.tm.tcf.services.ILocator; +import org.eclipse.tm.tcf.services.ILocator.LocatorListener; + +/** + * Abstract implementation of IPeer interface. + */ +public class AbstractPeer implements IPeer { + + private final Map ro_attrs; + private final Map rw_attrs; + + private long last_heart_beat_time; + + public AbstractPeer(Map attrs) { + assert Protocol.isDispatchThread(); + if (attrs != null) { + rw_attrs = new HashMap(attrs); + } + else { + rw_attrs = new HashMap(); + } + ro_attrs = Collections.unmodifiableMap(rw_attrs); + assert getID() != null; + LocatorService.addPeer(this); + } + + void onChannelTerminated() { + // A channel to this peer was terminated: + // not delaying next heart beat helps client to recover much faster. + last_heart_beat_time = 0; + } + + public void updateAttributes(Map attrs) { + boolean equ = true; + assert attrs.get(ATTR_ID).equals(rw_attrs.get(ATTR_ID)); + for (Iterator i = rw_attrs.keySet().iterator(); i.hasNext();) { + String key = i.next(); + if (!rw_attrs.get(key).equals(attrs.get(key))) { + equ = false; + break; + } + } + for (Iterator i = attrs.keySet().iterator(); i.hasNext();) { + String key = i.next(); + if (!attrs.get(key).equals(rw_attrs.get(key))) { + equ = false; + break; + } + } + long time = System.currentTimeMillis(); + if (!equ) { + rw_attrs.clear(); + rw_attrs.putAll(attrs); + for (LocatorListener l : LocatorService.getListeners()) { + try { + l.peerChanged(this); + } + catch (Throwable x) { + Protocol.log("Unhandled exception in Locator listener", x); + } + } + try { + Object[] args = { rw_attrs }; + Protocol.sendEvent(ILocator.NAME, "peerChanged", JSON.toJSONSequence(args)); + } + catch (IOException x) { + Protocol.log("Locator: failed to send 'peerChanged' event", x); + } + last_heart_beat_time = time; + } + else if (last_heart_beat_time + ILocator.DATA_RETENTION_PERIOD / 4 < time) { + for (LocatorListener l : LocatorService.getListeners()) { + try { + l.peerHeartBeat(attrs.get(ATTR_ID)); + } + catch (Throwable x) { + Protocol.log("Unhandled exception in Locator listener", x); + } + } + try { + Object[] args = { rw_attrs.get(ATTR_ID) }; + Protocol.sendEvent(ILocator.NAME, "peerHeartBeat", JSON.toJSONSequence(args)); + } + catch (IOException x) { + Protocol.log("Locator: failed to send 'peerHeartBeat' event", x); + } + last_heart_beat_time = time; + } + } + + public void sendPeerAddedEvent() { + for (LocatorListener l : LocatorService.getListeners()) { + try { + l.peerAdded(this); + } + catch (Throwable x) { + Protocol.log("Unhandled exception in Locator listener", x); + } + } + try { + Object[] args = { rw_attrs }; + Protocol.sendEvent(ILocator.NAME, "peerAdded", JSON.toJSONSequence(args)); + } + catch (IOException x) { + Protocol.log("Locator: failed to send 'peerAdded' event", x); + } + last_heart_beat_time = System.currentTimeMillis(); + } + + public void sendPeerRemovedEvent() { + for (LocatorListener l : LocatorService.getListeners()) { + try { + l.peerRemoved(rw_attrs.get(ATTR_ID)); + } + catch (Throwable x) { + Protocol.log("Unhandled exception in Locator listener", x); + } + } + try { + Object[] args = { rw_attrs.get(ATTR_ID) }; + Protocol.sendEvent(ILocator.NAME, "peerRemoved", JSON.toJSONSequence(args)); + } + catch (IOException x) { + Protocol.log("Locator: failed to send 'peerRemoved' event", x); + } + } + + public void dispose() { + assert Protocol.isDispatchThread(); + TransportManager.peerDisposed(this); + LocatorService.removePeer(this); + } + + public Map getAttributes() { + assert Protocol.isDispatchThread(); + return ro_attrs; + } + + public String getID() { + assert Protocol.isDispatchThread(); + return ro_attrs.get(ATTR_ID); + } + + public String getName() { + assert Protocol.isDispatchThread(); + return ro_attrs.get(ATTR_NAME); + } + + public String getOSName() { + assert Protocol.isDispatchThread(); + return ro_attrs.get(ATTR_OS_NAME); + } + + public String getTransportName() { + assert Protocol.isDispatchThread(); + return ro_attrs.get(ATTR_TRANSPORT_NAME); + } + + public IChannel openChannel() { + return TransportManager.openChannel(this); + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/tcf/core/Base64.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/tcf/core/Base64.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,148 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.tcf.core; + +/** + * Methods for translating Base64 encoded strings to byte arrays and back. + * @noextend This class is not intended to be subclassed by clients. + * @noinstantiate This class is not intended to be instantiated by clients. + */ +public final class Base64 { + + public static char[] toBase64(byte[] buf, int pos, int len) { + char[] out_buf = new char[4 * ((len + 2) / 3)]; + int end = pos + len; + int out_pos = 0; + while (pos < end) { + int byte0 = buf[pos++] & 0xff; + out_buf[out_pos++] = int2char[byte0 >> 2]; + if (pos == end) { + out_buf[out_pos++] = int2char[(byte0 << 4) & 0x3f]; + out_buf[out_pos++] = '='; + out_buf[out_pos++] = '='; + } + else { + int byte1 = buf[pos++] & 0xff; + out_buf[out_pos++] = int2char[(byte0 << 4) & 0x3f | (byte1 >> 4)]; + if (pos == end) { + out_buf[out_pos++] = int2char[(byte1 << 2) & 0x3f]; + out_buf[out_pos++] = '='; + } + else { + int byte2 = buf[pos++] & 0xff; + out_buf[out_pos++] = int2char[(byte1 << 2) & 0x3f | (byte2 >> 6)]; + out_buf[out_pos++] = int2char[byte2 & 0x3f]; + } + } + } + assert out_pos == out_buf.length; + return out_buf; + } + + public static void toByteArray(byte[] buf, int offs, int size, char[] inp) { + int out_pos = offs; + if (inp != null) { + int inp_len = inp.length; + if (inp_len % 4 != 0) { + throw new IllegalArgumentException( + "BASE64 string length must be a multiple of four."); + } + int out_len = inp_len / 4 * 3; + if (inp_len > 0 && inp[inp_len - 1] == '=') { + out_len--; + if (inp[inp_len - 2] == '=') { + out_len--; + } + } + if (out_len > size) { + throw new IllegalArgumentException( + "BASE64 data array is longer then destination buffer."); + } + int inp_pos = 0; + while (inp_pos < inp_len) { + int n0, n1, n2, n3; + char ch0 = inp[inp_pos++]; + char ch1 = inp[inp_pos++]; + char ch2 = inp[inp_pos++]; + char ch3 = inp[inp_pos++]; + if (ch0 >= char2int.length || (n0 = char2int[ch0]) < 0) { + throw new IllegalArgumentException("Illegal character " + ch0); + } + if (ch1 >= char2int.length || (n1 = char2int[ch1]) < 0) { + throw new IllegalArgumentException("Illegal character " + ch1); + } + buf[out_pos++] = (byte)((n0 << 2) | (n1 >> 4)); + if (ch2 == '=') break; + if (ch2 >= char2int.length || (n2 = char2int[ch2]) < 0) { + throw new IllegalArgumentException("Illegal character " + ch2); + } + buf[out_pos++] = (byte)((n1 << 4) | (n2 >> 2)); + if (ch3 == '=') break; + if (ch3 >= char2int.length || (n3 = char2int[ch3]) < 0) { + throw new IllegalArgumentException("Illegal character " + ch3); + } + buf[out_pos++] = (byte)((n2 << 6) | n3); + } + assert out_pos == offs + out_len; + } + while (out_pos < offs + size) buf[out_pos++] = 0; + } + + public static byte[] toByteArray(char[] inp) { + int inp_len = inp.length; + int out_len = inp_len / 4 * 3; + if (inp_len > 0 && inp[inp_len - 1] == '=') { + out_len--; + if (inp[inp_len - 2] == '=') { + out_len--; + } + } + byte[] buf = new byte[out_len]; + toByteArray(buf, 0, buf.length, inp); + return buf; + } + + /* + * See RFC 2045. + */ + private static final char int2char[] = { + 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', + 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', + 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', + 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', + 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', + 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', + 'w', 'x', 'y', 'z', '0', '1', '2', '3', + '4', '5', '6', '7', '8', '9', '+', '/' + }; + + /* + * See RFC 2045 + */ + private static final byte char2int[] = { + -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 62, -1, -1, -1, 63, + 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, -1, -1, -1, -1, -1, -1, + -1, 0, 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, -1, -1, -1, -1, -1, + -1, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51 + }; +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/tcf/core/ChannelTCP.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/tcf/core/ChannelTCP.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,149 @@ +/******************************************************************************* + * Copyright (c) 2007, 2009 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.tcf.core; + +import java.io.BufferedInputStream; +import java.io.BufferedOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.Socket; +import java.net.SocketException; + +import javax.net.ssl.SSLContext; +import javax.net.ssl.SSLSocket; + +import org.eclipse.tm.tcf.protocol.IPeer; +import org.eclipse.tm.tcf.protocol.Protocol; + +/** + * ChannelTCP is a IChannel implementation that works on top of TCP sockets as a transport. + */ +public class ChannelTCP extends StreamChannel { + + private Socket socket; + private InputStream inp; + private OutputStream out; + private boolean started; + private boolean closed; + + private static SSLContext ssl_context; + + public static void setSSLContext(SSLContext ssl_context) { + ChannelTCP.ssl_context = ssl_context; + } + + public ChannelTCP(IPeer remote_peer, final String host, final int port, final boolean ssl) { + super(remote_peer); + Thread thread = new Thread() { + public void run() { + try { + if (ssl) { + if (ssl_context == null) throw new Exception("SSL context is not set"); + socket = ssl_context.getSocketFactory().createSocket(host, port); + } + else { + socket = new Socket(host, port); + } + socket.setTcpNoDelay(true); + socket.setKeepAlive(true); + if (ssl) ((SSLSocket)socket).startHandshake(); + inp = new BufferedInputStream(socket.getInputStream()); + out = new BufferedOutputStream(socket.getOutputStream()); + onSocketConnected(null); + } + catch (final Exception x) { + onSocketConnected(x); + } + } + }; + thread.setName("TCF Socket Connect"); + thread.start(); + } + + public ChannelTCP(IPeer remote_peer, String host, int port) { + this(remote_peer, host, port, false); + } + + public ChannelTCP(IPeer local_peer, IPeer remote_peer, Socket socket) throws IOException { + super(local_peer, remote_peer); + this.socket = socket; + socket.setTcpNoDelay(true); + inp = new BufferedInputStream(socket.getInputStream()); + out = new BufferedOutputStream(socket.getOutputStream()); + onSocketConnected(null); + } + + private void onSocketConnected(final Throwable x) { + Protocol.invokeLater(new Runnable() { + public void run() { + if (x != null) terminate(x); + if (closed) { + try { + if (socket != null) { + socket.close(); + if (out != null) out.close(); + if (inp != null) inp.close(); + } + } + catch (IOException y) { + Protocol.log("Cannot close socket", y); + } + } + else { + started = true; + start(); + } + } + }); + } + + @Override + protected final int get() throws IOException { + try { + if (closed) return -1; + return inp.read(); + } + catch (SocketException x) { + if (closed) return -1; + throw x; + } + } + + @Override + protected final void put(int b) throws IOException { + assert b >= 0 && b <= 0xff; + if (closed) return; + out.write(b); + } + + @Override + protected final void put(byte[] buf) throws IOException { + if (closed) return; + out.write(buf); + } + + @Override + protected final void flush() throws IOException { + if (closed) return; + out.flush(); + } + + @Override + protected void stop() throws IOException { + closed = true; + if (started) { + socket.close(); + out.close(); + inp.close(); + } + } +} diff -r b6b7ad8a25a3 -r 11a6943ebeb2 dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/tcf/core/Command.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dsdp/tm/tcf_0_3_x/org.eclipse.tm.tcf.core/src/org/eclipse/tm/tcf/core/Command.java Mon Aug 17 16:02:00 2009 -0500 @@ -0,0 +1,233 @@ +/******************************************************************************* + * Copyright (c) 2007, 2008 Wind River Systems, Inc. and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Wind River Systems - initial API and implementation + *******************************************************************************/ +package org.eclipse.tm.tcf.core; + +import java.io.IOException; +import java.text.MessageFormat; +import java.text.SimpleDateFormat; +import java.util.Collection; +import java.util.Date; +import java.util.Map; + +import org.eclipse.tm.internal.tcf.core.Token; +import org.eclipse.tm.tcf.protocol.IChannel; +import org.eclipse.tm.tcf.protocol.IErrorReport; +import org.eclipse.tm.tcf.protocol.IService; +import org.eclipse.tm.tcf.protocol.IToken; +import org.eclipse.tm.tcf.protocol.JSON; +import org.eclipse.tm.tcf.protocol.Protocol; + + +/** + * This is utility class that helps to implement sending a command and receiving + * command result over TCF communication channel. The class uses JSON to encode + * command arguments and to decode result data. + * + * The class also provides support for TCF standard error report encoding. + * + * Clients are expected to subclass Command and override done method. + * + * Note: most clients don't need to handle protocol commands directly and + * can use service APIs instead. Service API does all command encoding/decoding + * for a client. + * + * Typical usage example: + * + * public IToken getContext(String id, final DoneGetContext done) { + * return new Command(channel, IService.this, "getContext", new Object[]{ id }) { + * @Override + * public void done(Exception error, Object[] args) { + * Context ctx = null; + * if (error == null) { + * assert args.length == 2; + * error = toError(args[0]); + * if (args[1] != null) ctx = new Context(args[1]); + * } + * done.doneGetContext(token, error, ctx); + * } + * }.token; + * } + */ +public abstract class Command implements IChannel.ICommandListener { + + private final IService service; + private final String command; + private final Object[] args; + + public final IToken token; + + private boolean done; + + private static final SimpleDateFormat timestamp_format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); + + public Command(IChannel channel, IService service, String command, Object[] args) { + this.service = service; + this.command = command; + this.args = args; + IToken t = null; + try { + boolean zero_copy = ((AbstractChannel)channel).isZeroCopySupported(); + t = channel.sendCommand(service, command, JSON.toJSONSequence(args, zero_copy), this); + } + catch (Throwable y) { + t = new Token(); + final Exception x = y instanceof Exception ? (Exception)y : new Exception(y); + Protocol.invokeLater(new Runnable() { + public void run() { + assert !done; + done = true; + done(x, null); + } + }); + } + token = t; + } + + public void progress(IToken token, byte[] data) { + assert this.token == token; + } + + public void result(IToken token, byte[] data) { + assert this.token == token; + Exception error = null; + Object[] args = null; + try { + args = JSON.parseSequence(data); + } + catch (Exception e) { + error = e; + } + assert !done; + done = true; + done(error, args); + } + + public void terminated(IToken token, Exception error) { + assert this.token == token; + assert !done; + done = true; + done(error, null); + } + + public abstract void done(Exception error, Object[] args); + + public String getCommandString() { + StringBuffer buf = new StringBuffer(); + buf.append(service.getName()); + buf.append(' '); + buf.append(command); + if (args != null) { + for (int i = 0; i < args.length; i++) { + buf.append(i == 0 ? " " : ", "); + try { + buf.append(JSON.toJSON(args[i])); + } + catch (IOException x) { + buf.append("***"); + buf.append(x.getMessage()); + buf.append("***"); + } + } + } + return buf.toString(); + } + + @SuppressWarnings({ "unchecked" }) + public static String toErrorString(Object data) { + if (data == null) return null; + Map map = (Map)data; + String fmt = (String)map.get(IErrorReport.ERROR_FORMAT); + if (fmt != null) { + Collection

Version +	Date +	Change +
0.1 +	2008-01-10 +	Initial contribution +
0.2 +	2008-04-25 +	Added getCapabilities +
1.0 +	2008-05-06 +	Approved +

Version +	Date +	Change +
0.1 +	2008-01-10 +	Initial contribution +
1.0 +	2008-05-06 +	Approved +
1.1 +	2009-03-16 +	Added context properties +

Version +	Date +	Change +
0.1 +	2008-01-10 +	Initial contribution +
0.2 +	2009-02-26 +	Added signal and environment commands, and properties for standard I/O redirection +

Version +	Date +	Change +
0.1 +	2008-01-10 +	Initial contribution +
0.2 +	2008-04-23 +	Added get/set multiple +
1.0 +	2008-05-06 +	Approved +
1.1 +	2009-03-16 +	Added search command and several context properties +

Version +	Date +	Change +
0.1 +	2008-01-10 +	Initial contribution +
1.0 +	2008-05-06 +	Approved +

Version +	Date +	Change +
0.1 +	2009-03-17 +	Initial contribution +
0.2 +	2009-05-18 +	Added connect command +
0.3 +	2009-08-13 +	Added "context ID" argument in "created" event +

TCF Project Overview +	TCF project goals and results +
TCF: Getting Started +	Getting started with TCF - creating Eclipse workspace, building agent, making a first connection +
TCF Specifications +	Design goals, requirements and format of TCF communication protocol, + framework API and software design considerations +
TCF Services Definitions +	TCF communication model is based on the idea of services. + A service is a group of related commands, events and semantics. + New services are expected to be defined by developers of tools and target agents. + To achieve certain level of compatibility of tools/targets TCF inclides definitions + of common services +
TCF Context Identifier Explanation +	Most if not all TCF services functions need some way to identify what entity e.g. process, + thread, task, device on JTAG scan chain, etc they should operate on. + To do this TCF uses a context identifier (aka ContextId). This document is attempting to explain how + ContextIds are intended to be used +
TCF Agent Prototype +	+ Brief description of the TCF target agent prototype implementation +
+ TCF Agent Porting Guide +	A guide for porting and customizing TCF agent code +

TCF Agent Porting Guide

Table of Contents

+ Introduction +

+ Customizing and Porting TCF Agent +

+ Porting TCF Agent to a New OS Platform +

+ Porting TCF Agent to a New CPU Type +

+ Adding Support For a New Executable File Format +

+ Adding Support For a New Debug Data Format +

+ Adding Support For a New Communication Transport +

Introduction

Why +a single ContextId?

Context +identifier

Context +hierarchies

Accessing +context information

ContextId +formatting

ContextId +prefix

Context +information caching

Relationship +between services

Context +hierarchy roots

Target Communication Framework: Getting Started

Table of Contents

TCF Agent Prototype Implementation

Table of Contents

Command and Event Registration and Dispatch

Transport Layer

Input and Output Stream Interface and Library

Breakpoint

Run Control

System Monitoring

Agent Diagnostics

Command line interpreter

Error message display

Exception Handling

JSON Library

Double Linked List

Host OS Abstraction

Malloc Abstraction

Proxy

Test Application

Debug Logging

Target Communication Framework project

Index

Summary

Goals

Features

Reference implementation of a target agent

Prototype of a debugger based on Eclipse Debug Framework and TCF

Prototype of a system monitor and remote file access based on Remote System Explorer and TCF

Target Communication Framework Services - Breakpoints

Breakpoints Service

Target Communication Framework Services - File System

File System Service

Target Communication Framework Services - Memory

Memory Service

Target Communication Framework Services - Processes

Processes Service

Target Communication Framework Services - Registers

Registers Service